file_name
stringlengths 5
52
| name
stringlengths 4
95
| original_source_type
stringlengths 0
23k
| source_type
stringlengths 9
23k
| source_definition
stringlengths 9
57.9k
| source
dict | source_range
dict | file_context
stringlengths 0
721k
| dependencies
dict | opens_and_abbrevs
listlengths 2
94
| vconfig
dict | interleaved
bool 1
class | verbose_type
stringlengths 1
7.42k
| effect
stringclasses 118
values | effect_flags
sequencelengths 0
2
| mutual_with
sequencelengths 0
11
| ideal_premises
sequencelengths 0
236
| proof_features
sequencelengths 0
1
| is_simple_lemma
bool 2
classes | is_div
bool 2
classes | is_proof
bool 2
classes | is_simply_typed
bool 2
classes | is_type
bool 2
classes | partial_definition
stringlengths 5
3.99k
| completed_definiton
stringlengths 1
1.63M
| isa_cross_project_example
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Vale.X64.Lemmas.fsti | Vale.X64.Lemmas.valid_ocmp | val valid_ocmp (c: ocmp) (s: vale_state) : GTot bool | val valid_ocmp (c: ocmp) (s: vale_state) : GTot bool | let valid_ocmp (c:ocmp) (s:vale_state) : GTot bool =
BS.valid_ocmp c (state_to_S s) | {
"file_name": "vale/code/arch/x64/Vale.X64.Lemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 32,
"end_line": 67,
"start_col": 0,
"start_line": 66
} | module Vale.X64.Lemmas
open FStar.Mul
open Vale.Arch.Heap
open Vale.Arch.HeapImpl
open Vale.Arch.HeapLemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.Bytes_Code_s
module BS = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
unfold let code = BS.code
unfold let codes = BS.codes
unfold let ocmp = BS.ocmp
unfold let fuel = nat
let cf (flags:Flags.t) : Flags.flag_val_t = Flags.sel fCarry flags
let overflow (flags:Flags.t) : Flags.flag_val_t = Flags.sel fOverflow flags
let update_cf (flags:Flags.t) (new_cf:bool) = Flags.upd fCarry (Some new_cf) flags
let update_of (flags:Flags.t) (new_of:bool) = Flags.upd fOverflow (Some new_of) flags
unfold let machine_state = BS.machine_state
unfold let machine_eval_code = BS.machine_eval_code
let rec code_modifies_ghost (c:code) : bool =
match c with
| Ins (Instr _ _ (BS.AnnotateGhost _)) -> true
| Ins _ -> false
| Block cs -> codes_modifies_ghost cs
| IfElse _ c1 c2 -> code_modifies_ghost c1 || code_modifies_ghost c2
| While _ c -> code_modifies_ghost c
and codes_modifies_ghost (cs:codes) : bool =
match cs with
| [] -> false
| c::cs -> code_modifies_ghost c || codes_modifies_ghost cs
let core_state (ignore_ghost:bool) (s:machine_state) : machine_state =
{s with
BS.ms_trace = [];
BS.ms_heap = if ignore_ghost then heap_ignore_ghost_machine s.BS.ms_heap else s.BS.ms_heap;
}
let state_eq_S (ignore_ghost:bool) (s1 s2:machine_state) =
machine_state_eq (core_state ignore_ghost s1) (core_state ignore_ghost s2)
let state_eq_opt (ignore_ghost:bool) (s1 s2:option BS.machine_state) =
match (s1, s2) with
| (Some s1, Some s2) -> state_eq_S ignore_ghost s1 s2
| _ -> s1 == s2
let eval_code (c:code) (s0:vale_state) (f0:fuel) (s1:vale_state) : Type0 =
state_eq_opt (code_modifies_ghost c) (machine_eval_code c f0 (state_to_S s0)) (Some (state_to_S s1))
let eval_ins (c:code) (s0:vale_state) : Ghost (vale_state & fuel)
(requires Ins? c)
(ensures fun (sM, f0) -> eval_code c s0 f0 sM)
=
reveal_opaque (`%BS.machine_eval_code_ins) BS.machine_eval_code_ins;
let f0 = 0 in
let (Some sM) = machine_eval_code c f0 (state_to_S s0) in
lemma_to_of sM;
(state_of_S sM, f0)
let eval_ocmp (s:vale_state) (c:ocmp) : GTot bool = snd (BS.machine_eval_ocmp (state_to_S s) c) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Arch.HeapLemmas.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Lemmas.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "BS"
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"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
}
] | {
"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"
} | false | c: Vale.X64.Lemmas.ocmp -> s: Vale.X64.State.vale_state -> Prims.GTot Prims.bool | Prims.GTot | [
"sometrivial"
] | [] | [
"Vale.X64.Lemmas.ocmp",
"Vale.X64.State.vale_state",
"Vale.X64.Machine_Semantics_s.valid_ocmp",
"Vale.X64.StateLemmas.state_to_S",
"Prims.bool"
] | [] | false | false | false | false | false | let valid_ocmp (c: ocmp) (s: vale_state) : GTot bool =
| BS.valid_ocmp c (state_to_S s) | false |
Vale.X64.Lemmas.fsti | Vale.X64.Lemmas.eval_code | val eval_code (c: code) (s0: vale_state) (f0: fuel) (s1: vale_state) : Type0 | val eval_code (c: code) (s0: vale_state) (f0: fuel) (s1: vale_state) : Type0 | let eval_code (c:code) (s0:vale_state) (f0:fuel) (s1:vale_state) : Type0 =
state_eq_opt (code_modifies_ghost c) (machine_eval_code c f0 (state_to_S s0)) (Some (state_to_S s1)) | {
"file_name": "vale/code/arch/x64/Vale.X64.Lemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 102,
"end_line": 52,
"start_col": 0,
"start_line": 51
} | module Vale.X64.Lemmas
open FStar.Mul
open Vale.Arch.Heap
open Vale.Arch.HeapImpl
open Vale.Arch.HeapLemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.Bytes_Code_s
module BS = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
unfold let code = BS.code
unfold let codes = BS.codes
unfold let ocmp = BS.ocmp
unfold let fuel = nat
let cf (flags:Flags.t) : Flags.flag_val_t = Flags.sel fCarry flags
let overflow (flags:Flags.t) : Flags.flag_val_t = Flags.sel fOverflow flags
let update_cf (flags:Flags.t) (new_cf:bool) = Flags.upd fCarry (Some new_cf) flags
let update_of (flags:Flags.t) (new_of:bool) = Flags.upd fOverflow (Some new_of) flags
unfold let machine_state = BS.machine_state
unfold let machine_eval_code = BS.machine_eval_code
let rec code_modifies_ghost (c:code) : bool =
match c with
| Ins (Instr _ _ (BS.AnnotateGhost _)) -> true
| Ins _ -> false
| Block cs -> codes_modifies_ghost cs
| IfElse _ c1 c2 -> code_modifies_ghost c1 || code_modifies_ghost c2
| While _ c -> code_modifies_ghost c
and codes_modifies_ghost (cs:codes) : bool =
match cs with
| [] -> false
| c::cs -> code_modifies_ghost c || codes_modifies_ghost cs
let core_state (ignore_ghost:bool) (s:machine_state) : machine_state =
{s with
BS.ms_trace = [];
BS.ms_heap = if ignore_ghost then heap_ignore_ghost_machine s.BS.ms_heap else s.BS.ms_heap;
}
let state_eq_S (ignore_ghost:bool) (s1 s2:machine_state) =
machine_state_eq (core_state ignore_ghost s1) (core_state ignore_ghost s2)
let state_eq_opt (ignore_ghost:bool) (s1 s2:option BS.machine_state) =
match (s1, s2) with
| (Some s1, Some s2) -> state_eq_S ignore_ghost s1 s2
| _ -> s1 == s2 | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Arch.HeapLemmas.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Lemmas.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "BS"
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"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
}
] | {
"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"
} | false |
c: Vale.X64.Lemmas.code ->
s0: Vale.X64.State.vale_state ->
f0: Vale.X64.Lemmas.fuel ->
s1: Vale.X64.State.vale_state
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Lemmas.code",
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.fuel",
"Vale.X64.Lemmas.state_eq_opt",
"Vale.X64.Lemmas.code_modifies_ghost",
"Vale.X64.Lemmas.machine_eval_code",
"Vale.X64.StateLemmas.state_to_S",
"FStar.Pervasives.Native.Some",
"Vale.X64.Machine_Semantics_s.machine_state"
] | [] | false | false | false | true | true | let eval_code (c: code) (s0: vale_state) (f0: fuel) (s1: vale_state) : Type0 =
| state_eq_opt (code_modifies_ghost c) (machine_eval_code c f0 (state_to_S s0)) (Some (state_to_S s1)) | false |
Hacl.Bignum.Montgomery.fst | Hacl.Bignum.Montgomery.bn_mont_reduction_loop_div_r | val bn_mont_reduction_loop_div_r: #t:limb_t -> k:BN.bn t -> bn_mont_reduction_loop_div_r_st t k.BN.len | val bn_mont_reduction_loop_div_r: #t:limb_t -> k:BN.bn t -> bn_mont_reduction_loop_div_r_st t k.BN.len | let bn_mont_reduction_loop_div_r #t k n nInv c res =
[@inline_let] let len = k.BN.len in
push_frame ();
let c0 = create 1ul (uint #t 0) in
[@inline_let]
let refl h i : GTot (S.bn_mont_reduction_t i) = Seq.index (as_seq h c0) 0, as_seq h c in
[@inline_let]
let footprint i = loc c0 |+| loc c in
[@ inline_let]
let spec h = S.bn_mont_reduction_f (as_seq h n) nInv in
let h0 = ST.get () in
loop h0 len S.bn_mont_reduction_t refl footprint spec
(fun j ->
Loops.unfold_repeat_gen (v len) S.bn_mont_reduction_t (spec h0) (refl h0 0) (v j);
bn_mont_reduction_f len n nInv j c0 c
);
BN.bn_rshift (len +! len) c len res;
let c0 = c0.(0ul) in
pop_frame ();
c0 | {
"file_name": "code/bignum/Hacl.Bignum.Montgomery.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 4,
"end_line": 129,
"start_col": 0,
"start_line": 109
} | module Hacl.Bignum.Montgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
module ST = FStar.HyperStack.ST
module Loops = Lib.LoopCombinators
module LSeq = Lib.Sequence
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Montgomery
module SB = Hacl.Spec.Bignum
module BN = Hacl.Bignum
friend Hacl.Spec.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_modulus #t #len n =
push_frame ();
let one = create len (uint #t 0) in
BN.bn_from_uint len (uint #t 1) one;
let bit0 = BN.bn_is_odd len n in
let m0 = uint #t 0 -. bit0 in
let m1 = BN.bn_lt_mask len one n in
let m = m0 &. m1 in
pop_frame ();
m
let bn_precomp_r2_mod_n #t k nBits n res =
[@inline_let] let len = k.BN.len in
memset res (uint #t 0) len;
BN.bn_set_ith_bit len res nBits;
[@inline_let]
let spec h = S.bn_lshift1_mod_n (as_seq h n) in
let h0 = ST.get () in
loop1 h0 (2ul *! size (bits t) *! len -! nBits) res spec
(fun i ->
Loops.unfold_repeati (2 * bits t * v len - v nBits) (spec h0) (as_seq h0 res) (v i);
BN.add_mod_n n res res res
)
let bn_mont_precomp #t len precompr2 nBits n r2 =
precompr2 nBits n r2;
mod_inv_limb n.(0ul)
inline_for_extraction noextract
val bn_mont_reduction_f:
#t:limb_t
-> len:size_t{v len + v len <= max_size_t}
-> n:lbignum t len
-> nInv:(limb t)
-> j:size_t{v j < v len}
-> c:lbuffer (carry t) 1ul
-> res:lbignum t (len +! len) ->
Stack unit
(requires fun h ->
live h n /\ live h res /\ live h c /\
disjoint n res /\ disjoint n c /\ disjoint c res)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
(Seq.index (as_seq h1 c) 0, as_seq h1 res) ==
S.bn_mont_reduction_f (as_seq h0 n) nInv (v j) (Seq.index (as_seq h0 c) 0, as_seq h0 res))
let bn_mont_reduction_f #t len n nInv j c res =
let qj = nInv *. res.(j) in
// Keeping the inline_for_extraction version here.
let c1 = BN.bn_mul1_lshift_add_in_place len n qj (len +! len) j res in
let h0 = ST.get () in
let resb = sub res (len +! j) 1ul in
let res_j = res.(len +! j) in
c.(0ul) <- addcarry_st c.(0ul) c1 res_j resb;
let h1 = ST.get () in
let tmp = sub res (len +! j) 1ul in
B.modifies_buffer_elim (B.gsub #(limb t) res 0ul (len +! j)) (loc c |+| loc tmp) h0 h1;
assert (v (len +! j +! 1ul) + v (len +! len -! len -! j -! 1ul) == v (len +! len));
B.modifies_buffer_elim (B.gsub #(limb t) res (len +! j +! 1ul) (len -! j -! 1ul)) (loc c |+| loc tmp) h0 h1;
LSeq.lemma_update_sub (as_seq h0 res) (v len + v j) 1 (LSeq.sub (as_seq h1 res) (v len + v j) 1) (as_seq h1 res);
LSeq.eq_intro (as_seq h1 res) (LSeq.upd (as_seq h0 res) (v len + v j) (Seq.index (as_seq h1 res) (v len + v j)))
inline_for_extraction noextract
let bn_mont_reduction_loop_div_r_st (t:limb_t) (len:size_t{0 < v len /\ v len + v len <= max_size_t}) =
n:lbignum t len
-> mu:limb t
-> c:lbignum t (len +! len)
-> res:lbignum t len ->
Stack (carry t)
(requires fun h ->
live h n /\ live h c /\ live h res /\
disjoint res n /\ disjoint res c /\ disjoint n c)
(ensures fun h0 c0 h1 -> modifies (loc res |+| loc c) h0 h1 /\
(c0, as_seq h1 res) == S.bn_mont_reduction_loop_div_r (as_seq h0 n) mu (as_seq h0 c))
inline_for_extraction noextract | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum.Montgomery.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.ModInvLimb",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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"
} | false | k: Hacl.Bignum.bn t -> Hacl.Bignum.Montgomery.bn_mont_reduction_loop_div_r_st t (Mkbn?.len k) | Prims.Tot | [
"total"
] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Hacl.Bignum.bn",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.__proj__Mkbn__item__len",
"Hacl.Bignum.Definitions.limb",
"Lib.IntTypes.op_Plus_Bang",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Spec.Bignum.Base.carry",
"Prims.unit",
"FStar.HyperStack.ST.pop_frame",
"Lib.Buffer.op_Array_Access",
"Lib.Buffer.MUT",
"FStar.UInt32.__uint_to_t",
"Hacl.Bignum.bn_rshift",
"Lib.Buffer.loop",
"Hacl.Spec.Bignum.Montgomery.bn_mont_reduction_t",
"Lib.IntTypes.v",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThan",
"Hacl.Bignum.Montgomery.bn_mont_reduction_f",
"Lib.LoopCombinators.unfold_repeat_gen",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"FStar.Pervasives.Native.tuple2",
"Hacl.Spec.Bignum.Definitions.lbignum",
"Prims.op_Addition",
"Hacl.Spec.Bignum.Montgomery.bn_mont_reduction_f",
"Lib.Buffer.as_seq",
"LowStar.Monotonic.Buffer.loc",
"Lib.IntTypes.size_nat",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.index",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.create",
"Lib.IntTypes.uint",
"Lib.IntTypes.SEC",
"Lib.Buffer.lbuffer",
"FStar.HyperStack.ST.push_frame",
"Hacl.Bignum.meta_len"
] | [] | false | false | false | false | false | let bn_mont_reduction_loop_div_r #t k n nInv c res =
| [@@ inline_let ]let len = k.BN.len in
push_frame ();
let c0 = create 1ul (uint #t 0) in
[@@ inline_let ]let refl h i : GTot (S.bn_mont_reduction_t i) =
Seq.index (as_seq h c0) 0, as_seq h c
in
[@@ inline_let ]let footprint i = loc c0 |+| loc c in
[@@ inline_let ]let spec h = S.bn_mont_reduction_f (as_seq h n) nInv in
let h0 = ST.get () in
loop h0
len
S.bn_mont_reduction_t
refl
footprint
spec
(fun j ->
Loops.unfold_repeat_gen (v len) S.bn_mont_reduction_t (spec h0) (refl h0 0) (v j);
bn_mont_reduction_f len n nInv j c0 c);
BN.bn_rshift (len +! len) c len res;
let c0 = c0.(0ul) in
pop_frame ();
c0 | false |
Vale.X64.Lemmas.fsti | Vale.X64.Lemmas.havoc_flags | val havoc_flags:Flags.t | val havoc_flags:Flags.t | let havoc_flags : Flags.t =
Flags.of_fun BS.havoc_flags | {
"file_name": "vale/code/arch/x64/Vale.X64.Lemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 29,
"end_line": 70,
"start_col": 0,
"start_line": 69
} | module Vale.X64.Lemmas
open FStar.Mul
open Vale.Arch.Heap
open Vale.Arch.HeapImpl
open Vale.Arch.HeapLemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.Bytes_Code_s
module BS = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
unfold let code = BS.code
unfold let codes = BS.codes
unfold let ocmp = BS.ocmp
unfold let fuel = nat
let cf (flags:Flags.t) : Flags.flag_val_t = Flags.sel fCarry flags
let overflow (flags:Flags.t) : Flags.flag_val_t = Flags.sel fOverflow flags
let update_cf (flags:Flags.t) (new_cf:bool) = Flags.upd fCarry (Some new_cf) flags
let update_of (flags:Flags.t) (new_of:bool) = Flags.upd fOverflow (Some new_of) flags
unfold let machine_state = BS.machine_state
unfold let machine_eval_code = BS.machine_eval_code
let rec code_modifies_ghost (c:code) : bool =
match c with
| Ins (Instr _ _ (BS.AnnotateGhost _)) -> true
| Ins _ -> false
| Block cs -> codes_modifies_ghost cs
| IfElse _ c1 c2 -> code_modifies_ghost c1 || code_modifies_ghost c2
| While _ c -> code_modifies_ghost c
and codes_modifies_ghost (cs:codes) : bool =
match cs with
| [] -> false
| c::cs -> code_modifies_ghost c || codes_modifies_ghost cs
let core_state (ignore_ghost:bool) (s:machine_state) : machine_state =
{s with
BS.ms_trace = [];
BS.ms_heap = if ignore_ghost then heap_ignore_ghost_machine s.BS.ms_heap else s.BS.ms_heap;
}
let state_eq_S (ignore_ghost:bool) (s1 s2:machine_state) =
machine_state_eq (core_state ignore_ghost s1) (core_state ignore_ghost s2)
let state_eq_opt (ignore_ghost:bool) (s1 s2:option BS.machine_state) =
match (s1, s2) with
| (Some s1, Some s2) -> state_eq_S ignore_ghost s1 s2
| _ -> s1 == s2
let eval_code (c:code) (s0:vale_state) (f0:fuel) (s1:vale_state) : Type0 =
state_eq_opt (code_modifies_ghost c) (machine_eval_code c f0 (state_to_S s0)) (Some (state_to_S s1))
let eval_ins (c:code) (s0:vale_state) : Ghost (vale_state & fuel)
(requires Ins? c)
(ensures fun (sM, f0) -> eval_code c s0 f0 sM)
=
reveal_opaque (`%BS.machine_eval_code_ins) BS.machine_eval_code_ins;
let f0 = 0 in
let (Some sM) = machine_eval_code c f0 (state_to_S s0) in
lemma_to_of sM;
(state_of_S sM, f0)
let eval_ocmp (s:vale_state) (c:ocmp) : GTot bool = snd (BS.machine_eval_ocmp (state_to_S s) c)
let valid_ocmp (c:ocmp) (s:vale_state) : GTot bool =
BS.valid_ocmp c (state_to_S s) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Arch.HeapLemmas.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Lemmas.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "BS"
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"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
}
] | {
"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"
} | false | Vale.X64.Flags.t | Prims.Tot | [
"total"
] | [] | [
"Vale.X64.Flags.of_fun",
"Vale.X64.Machine_Semantics_s.havoc_flags"
] | [] | false | false | false | true | false | let havoc_flags:Flags.t =
| Flags.of_fun BS.havoc_flags | false |
Vale.X64.Lemmas.fsti | Vale.X64.Lemmas.eval_ocmp | val eval_ocmp (s: vale_state) (c: ocmp) : GTot bool | val eval_ocmp (s: vale_state) (c: ocmp) : GTot bool | let eval_ocmp (s:vale_state) (c:ocmp) : GTot bool = snd (BS.machine_eval_ocmp (state_to_S s) c) | {
"file_name": "vale/code/arch/x64/Vale.X64.Lemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 95,
"end_line": 64,
"start_col": 0,
"start_line": 64
} | module Vale.X64.Lemmas
open FStar.Mul
open Vale.Arch.Heap
open Vale.Arch.HeapImpl
open Vale.Arch.HeapLemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.Bytes_Code_s
module BS = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
unfold let code = BS.code
unfold let codes = BS.codes
unfold let ocmp = BS.ocmp
unfold let fuel = nat
let cf (flags:Flags.t) : Flags.flag_val_t = Flags.sel fCarry flags
let overflow (flags:Flags.t) : Flags.flag_val_t = Flags.sel fOverflow flags
let update_cf (flags:Flags.t) (new_cf:bool) = Flags.upd fCarry (Some new_cf) flags
let update_of (flags:Flags.t) (new_of:bool) = Flags.upd fOverflow (Some new_of) flags
unfold let machine_state = BS.machine_state
unfold let machine_eval_code = BS.machine_eval_code
let rec code_modifies_ghost (c:code) : bool =
match c with
| Ins (Instr _ _ (BS.AnnotateGhost _)) -> true
| Ins _ -> false
| Block cs -> codes_modifies_ghost cs
| IfElse _ c1 c2 -> code_modifies_ghost c1 || code_modifies_ghost c2
| While _ c -> code_modifies_ghost c
and codes_modifies_ghost (cs:codes) : bool =
match cs with
| [] -> false
| c::cs -> code_modifies_ghost c || codes_modifies_ghost cs
let core_state (ignore_ghost:bool) (s:machine_state) : machine_state =
{s with
BS.ms_trace = [];
BS.ms_heap = if ignore_ghost then heap_ignore_ghost_machine s.BS.ms_heap else s.BS.ms_heap;
}
let state_eq_S (ignore_ghost:bool) (s1 s2:machine_state) =
machine_state_eq (core_state ignore_ghost s1) (core_state ignore_ghost s2)
let state_eq_opt (ignore_ghost:bool) (s1 s2:option BS.machine_state) =
match (s1, s2) with
| (Some s1, Some s2) -> state_eq_S ignore_ghost s1 s2
| _ -> s1 == s2
let eval_code (c:code) (s0:vale_state) (f0:fuel) (s1:vale_state) : Type0 =
state_eq_opt (code_modifies_ghost c) (machine_eval_code c f0 (state_to_S s0)) (Some (state_to_S s1))
let eval_ins (c:code) (s0:vale_state) : Ghost (vale_state & fuel)
(requires Ins? c)
(ensures fun (sM, f0) -> eval_code c s0 f0 sM)
=
reveal_opaque (`%BS.machine_eval_code_ins) BS.machine_eval_code_ins;
let f0 = 0 in
let (Some sM) = machine_eval_code c f0 (state_to_S s0) in
lemma_to_of sM;
(state_of_S sM, f0) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Arch.HeapLemmas.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Lemmas.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "BS"
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"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
}
] | {
"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"
} | false | s: Vale.X64.State.vale_state -> c: Vale.X64.Lemmas.ocmp -> Prims.GTot Prims.bool | Prims.GTot | [
"sometrivial"
] | [] | [
"Vale.X64.State.vale_state",
"Vale.X64.Lemmas.ocmp",
"FStar.Pervasives.Native.snd",
"Vale.X64.Machine_Semantics_s.machine_state",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.machine_eval_ocmp",
"Vale.X64.StateLemmas.state_to_S"
] | [] | false | false | false | false | false | let eval_ocmp (s: vale_state) (c: ocmp) : GTot bool =
| snd (BS.machine_eval_ocmp (state_to_S s) c) | false |
Vale.X64.Lemmas.fsti | Vale.X64.Lemmas.ensure_valid_ocmp | val ensure_valid_ocmp (c: ocmp) (s: vale_state) : GTot vale_state | val ensure_valid_ocmp (c: ocmp) (s: vale_state) : GTot vale_state | let ensure_valid_ocmp (c:ocmp) (s:vale_state) : GTot vale_state =
let ts:machine_state = fst (BS.machine_eval_ocmp (state_to_S s) c) in
state_of_S ts | {
"file_name": "vale/code/arch/x64/Vale.X64.Lemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 15,
"end_line": 74,
"start_col": 0,
"start_line": 72
} | module Vale.X64.Lemmas
open FStar.Mul
open Vale.Arch.Heap
open Vale.Arch.HeapImpl
open Vale.Arch.HeapLemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.Bytes_Code_s
module BS = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
unfold let code = BS.code
unfold let codes = BS.codes
unfold let ocmp = BS.ocmp
unfold let fuel = nat
let cf (flags:Flags.t) : Flags.flag_val_t = Flags.sel fCarry flags
let overflow (flags:Flags.t) : Flags.flag_val_t = Flags.sel fOverflow flags
let update_cf (flags:Flags.t) (new_cf:bool) = Flags.upd fCarry (Some new_cf) flags
let update_of (flags:Flags.t) (new_of:bool) = Flags.upd fOverflow (Some new_of) flags
unfold let machine_state = BS.machine_state
unfold let machine_eval_code = BS.machine_eval_code
let rec code_modifies_ghost (c:code) : bool =
match c with
| Ins (Instr _ _ (BS.AnnotateGhost _)) -> true
| Ins _ -> false
| Block cs -> codes_modifies_ghost cs
| IfElse _ c1 c2 -> code_modifies_ghost c1 || code_modifies_ghost c2
| While _ c -> code_modifies_ghost c
and codes_modifies_ghost (cs:codes) : bool =
match cs with
| [] -> false
| c::cs -> code_modifies_ghost c || codes_modifies_ghost cs
let core_state (ignore_ghost:bool) (s:machine_state) : machine_state =
{s with
BS.ms_trace = [];
BS.ms_heap = if ignore_ghost then heap_ignore_ghost_machine s.BS.ms_heap else s.BS.ms_heap;
}
let state_eq_S (ignore_ghost:bool) (s1 s2:machine_state) =
machine_state_eq (core_state ignore_ghost s1) (core_state ignore_ghost s2)
let state_eq_opt (ignore_ghost:bool) (s1 s2:option BS.machine_state) =
match (s1, s2) with
| (Some s1, Some s2) -> state_eq_S ignore_ghost s1 s2
| _ -> s1 == s2
let eval_code (c:code) (s0:vale_state) (f0:fuel) (s1:vale_state) : Type0 =
state_eq_opt (code_modifies_ghost c) (machine_eval_code c f0 (state_to_S s0)) (Some (state_to_S s1))
let eval_ins (c:code) (s0:vale_state) : Ghost (vale_state & fuel)
(requires Ins? c)
(ensures fun (sM, f0) -> eval_code c s0 f0 sM)
=
reveal_opaque (`%BS.machine_eval_code_ins) BS.machine_eval_code_ins;
let f0 = 0 in
let (Some sM) = machine_eval_code c f0 (state_to_S s0) in
lemma_to_of sM;
(state_of_S sM, f0)
let eval_ocmp (s:vale_state) (c:ocmp) : GTot bool = snd (BS.machine_eval_ocmp (state_to_S s) c)
let valid_ocmp (c:ocmp) (s:vale_state) : GTot bool =
BS.valid_ocmp c (state_to_S s)
let havoc_flags : Flags.t =
Flags.of_fun BS.havoc_flags | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Arch.HeapLemmas.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Lemmas.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "BS"
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"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
}
] | {
"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"
} | false | c: Vale.X64.Lemmas.ocmp -> s: Vale.X64.State.vale_state -> Prims.GTot Vale.X64.State.vale_state | Prims.GTot | [
"sometrivial"
] | [] | [
"Vale.X64.Lemmas.ocmp",
"Vale.X64.State.vale_state",
"Vale.X64.StateLemmas.state_of_S",
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Pervasives.Native.fst",
"Prims.bool",
"Vale.X64.Machine_Semantics_s.machine_eval_ocmp",
"Vale.X64.StateLemmas.state_to_S"
] | [] | false | false | false | false | false | let ensure_valid_ocmp (c: ocmp) (s: vale_state) : GTot vale_state =
| let ts:machine_state = fst (BS.machine_eval_ocmp (state_to_S s) c) in
state_of_S ts | false |
Hacl.Impl.Exponentiation.Definitions.fst | Hacl.Impl.Exponentiation.Definitions.lone_st | val lone_st : a_t: Hacl.Impl.Exponentiation.Definitions.inttype_a ->
len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} ->
ctx_len: Lib.IntTypes.size_t ->
to: Hacl.Impl.Exponentiation.Definitions.to_comm_monoid a_t len ctx_len
-> Type0 | let lone_st
(a_t:inttype_a)
(len:size_t{v len > 0})
(ctx_len:size_t)
(to:to_comm_monoid a_t len ctx_len) =
ctx:lbuffer (uint_t a_t SEC) ctx_len
-> x:lbuffer (uint_t a_t SEC) len ->
Stack unit
(requires fun h ->
live h x /\ live h ctx /\ disjoint ctx x /\
to.linv_ctx (as_seq h ctx))
(ensures fun h0 _ h1 -> modifies (loc x) h0 h1 /\
to.linv (as_seq h1 x) /\
to.refl (as_seq h1 x) == to.comm_monoid.S.one) | {
"file_name": "code/bignum/Hacl.Impl.Exponentiation.Definitions.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 50,
"end_line": 43,
"start_col": 0,
"start_line": 30
} | module Hacl.Impl.Exponentiation.Definitions
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Lib.Exponentiation.Definition
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let inttype_a = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
class to_comm_monoid (a_t:inttype_a) (len:size_t{v len > 0}) (ctx_len:size_t) = {
a_spec: Type0;
comm_monoid: S.comm_monoid a_spec;
linv_ctx: x:LSeq.lseq (uint_t a_t SEC) (v ctx_len) -> Type0;
linv: x:LSeq.lseq (uint_t a_t SEC) (v len) -> Type0;
refl: x:LSeq.lseq (uint_t a_t SEC) (v len){linv x} -> GTot a_spec;
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Exponentiation.Definitions.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"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.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Exponentiation",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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"
} | false |
a_t: Hacl.Impl.Exponentiation.Definitions.inttype_a ->
len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} ->
ctx_len: Lib.IntTypes.size_t ->
to: Hacl.Impl.Exponentiation.Definitions.to_comm_monoid a_t len ctx_len
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.Definitions.inttype_a",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Exponentiation.Definitions.to_comm_monoid",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__linv_ctx",
"Lib.Buffer.as_seq",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__linv",
"Prims.eq2",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__a_spec",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__refl",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__one",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__comm_monoid"
] | [] | false | false | false | false | true | let lone_st
(a_t: inttype_a)
(len: size_t{v len > 0})
(ctx_len: size_t)
(to: to_comm_monoid a_t len ctx_len)
=
| ctx: lbuffer (uint_t a_t SEC) ctx_len -> x: lbuffer (uint_t a_t SEC) len
-> Stack unit
(requires fun h -> live h x /\ live h ctx /\ disjoint ctx x /\ to.linv_ctx (as_seq h ctx))
(ensures
fun h0 _ h1 ->
modifies (loc x) h0 h1 /\ to.linv (as_seq h1 x) /\
to.refl (as_seq h1 x) == to.comm_monoid.S.one) | false |
|
Hacl.Impl.Exponentiation.Definitions.fst | Hacl.Impl.Exponentiation.Definitions.lmul_st | val lmul_st : a_t: Hacl.Impl.Exponentiation.Definitions.inttype_a ->
len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} ->
ctx_len: Lib.IntTypes.size_t ->
to: Hacl.Impl.Exponentiation.Definitions.to_comm_monoid a_t len ctx_len
-> Type0 | let lmul_st
(a_t:inttype_a)
(len:size_t{v len > 0})
(ctx_len:size_t)
(to:to_comm_monoid a_t len ctx_len) =
ctx:lbuffer (uint_t a_t SEC) ctx_len
-> x:lbuffer (uint_t a_t SEC) len
-> y:lbuffer (uint_t a_t SEC) len
-> xy:lbuffer (uint_t a_t SEC) len ->
Stack unit
(requires fun h ->
live h x /\ live h y /\ live h xy /\ live h ctx /\
eq_or_disjoint x xy /\ eq_or_disjoint y xy /\ eq_or_disjoint x y /\
disjoint ctx x /\ disjoint ctx y /\ disjoint ctx xy /\
to.linv (as_seq h x) /\ to.linv (as_seq h y) /\ to.linv_ctx (as_seq h ctx))
(ensures fun h0 _ h1 -> modifies (loc xy) h0 h1 /\ to.linv (as_seq h1 xy) /\
to.refl (as_seq h1 xy) == to.comm_monoid.S.mul (to.refl (as_seq h0 x)) (to.refl (as_seq h0 y))) | {
"file_name": "code/bignum/Hacl.Impl.Exponentiation.Definitions.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 99,
"end_line": 63,
"start_col": 0,
"start_line": 47
} | module Hacl.Impl.Exponentiation.Definitions
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Lib.Exponentiation.Definition
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let inttype_a = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
class to_comm_monoid (a_t:inttype_a) (len:size_t{v len > 0}) (ctx_len:size_t) = {
a_spec: Type0;
comm_monoid: S.comm_monoid a_spec;
linv_ctx: x:LSeq.lseq (uint_t a_t SEC) (v ctx_len) -> Type0;
linv: x:LSeq.lseq (uint_t a_t SEC) (v len) -> Type0;
refl: x:LSeq.lseq (uint_t a_t SEC) (v len){linv x} -> GTot a_spec;
}
inline_for_extraction noextract
let lone_st
(a_t:inttype_a)
(len:size_t{v len > 0})
(ctx_len:size_t)
(to:to_comm_monoid a_t len ctx_len) =
ctx:lbuffer (uint_t a_t SEC) ctx_len
-> x:lbuffer (uint_t a_t SEC) len ->
Stack unit
(requires fun h ->
live h x /\ live h ctx /\ disjoint ctx x /\
to.linv_ctx (as_seq h ctx))
(ensures fun h0 _ h1 -> modifies (loc x) h0 h1 /\
to.linv (as_seq h1 x) /\
to.refl (as_seq h1 x) == to.comm_monoid.S.one) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Exponentiation.Definitions.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"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.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Exponentiation",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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"
} | false |
a_t: Hacl.Impl.Exponentiation.Definitions.inttype_a ->
len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} ->
ctx_len: Lib.IntTypes.size_t ->
to: Hacl.Impl.Exponentiation.Definitions.to_comm_monoid a_t len ctx_len
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.Definitions.inttype_a",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Exponentiation.Definitions.to_comm_monoid",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.eq_or_disjoint",
"Lib.Buffer.disjoint",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__linv",
"Lib.Buffer.as_seq",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__linv_ctx",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Prims.eq2",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__a_spec",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__refl",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__comm_monoid"
] | [] | false | false | false | false | true | let lmul_st
(a_t: inttype_a)
(len: size_t{v len > 0})
(ctx_len: size_t)
(to: to_comm_monoid a_t len ctx_len)
=
|
ctx: lbuffer (uint_t a_t SEC) ctx_len ->
x: lbuffer (uint_t a_t SEC) len ->
y: lbuffer (uint_t a_t SEC) len ->
xy: lbuffer (uint_t a_t SEC) len
-> Stack unit
(requires
fun h ->
live h x /\ live h y /\ live h xy /\ live h ctx /\ eq_or_disjoint x xy /\
eq_or_disjoint y xy /\ eq_or_disjoint x y /\ disjoint ctx x /\ disjoint ctx y /\
disjoint ctx xy /\ to.linv (as_seq h x) /\ to.linv (as_seq h y) /\
to.linv_ctx (as_seq h ctx))
(ensures
fun h0 _ h1 ->
modifies (loc xy) h0 h1 /\ to.linv (as_seq h1 xy) /\
to.refl (as_seq h1 xy) ==
to.comm_monoid.S.mul (to.refl (as_seq h0 x)) (to.refl (as_seq h0 y))) | false |
|
Hacl.Bignum.Montgomery.fst | Hacl.Bignum.Montgomery.bn_mont_reduction_f | val bn_mont_reduction_f:
#t:limb_t
-> len:size_t{v len + v len <= max_size_t}
-> n:lbignum t len
-> nInv:(limb t)
-> j:size_t{v j < v len}
-> c:lbuffer (carry t) 1ul
-> res:lbignum t (len +! len) ->
Stack unit
(requires fun h ->
live h n /\ live h res /\ live h c /\
disjoint n res /\ disjoint n c /\ disjoint c res)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
(Seq.index (as_seq h1 c) 0, as_seq h1 res) ==
S.bn_mont_reduction_f (as_seq h0 n) nInv (v j) (Seq.index (as_seq h0 c) 0, as_seq h0 res)) | val bn_mont_reduction_f:
#t:limb_t
-> len:size_t{v len + v len <= max_size_t}
-> n:lbignum t len
-> nInv:(limb t)
-> j:size_t{v j < v len}
-> c:lbuffer (carry t) 1ul
-> res:lbignum t (len +! len) ->
Stack unit
(requires fun h ->
live h n /\ live h res /\ live h c /\
disjoint n res /\ disjoint n c /\ disjoint c res)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
(Seq.index (as_seq h1 c) 0, as_seq h1 res) ==
S.bn_mont_reduction_f (as_seq h0 n) nInv (v j) (Seq.index (as_seq h0 c) 0, as_seq h0 res)) | let bn_mont_reduction_f #t len n nInv j c res =
let qj = nInv *. res.(j) in
// Keeping the inline_for_extraction version here.
let c1 = BN.bn_mul1_lshift_add_in_place len n qj (len +! len) j res in
let h0 = ST.get () in
let resb = sub res (len +! j) 1ul in
let res_j = res.(len +! j) in
c.(0ul) <- addcarry_st c.(0ul) c1 res_j resb;
let h1 = ST.get () in
let tmp = sub res (len +! j) 1ul in
B.modifies_buffer_elim (B.gsub #(limb t) res 0ul (len +! j)) (loc c |+| loc tmp) h0 h1;
assert (v (len +! j +! 1ul) + v (len +! len -! len -! j -! 1ul) == v (len +! len));
B.modifies_buffer_elim (B.gsub #(limb t) res (len +! j +! 1ul) (len -! j -! 1ul)) (loc c |+| loc tmp) h0 h1;
LSeq.lemma_update_sub (as_seq h0 res) (v len + v j) 1 (LSeq.sub (as_seq h1 res) (v len + v j) 1) (as_seq h1 res);
LSeq.eq_intro (as_seq h1 res) (LSeq.upd (as_seq h0 res) (v len + v j) (Seq.index (as_seq h1 res) (v len + v j))) | {
"file_name": "code/bignum/Hacl.Bignum.Montgomery.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 114,
"end_line": 90,
"start_col": 0,
"start_line": 76
} | module Hacl.Bignum.Montgomery
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum.Definitions
open Hacl.Bignum.Base
module ST = FStar.HyperStack.ST
module Loops = Lib.LoopCombinators
module LSeq = Lib.Sequence
module B = LowStar.Buffer
module S = Hacl.Spec.Bignum.Montgomery
module SB = Hacl.Spec.Bignum
module BN = Hacl.Bignum
friend Hacl.Spec.Bignum.Montgomery
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
let bn_check_modulus #t #len n =
push_frame ();
let one = create len (uint #t 0) in
BN.bn_from_uint len (uint #t 1) one;
let bit0 = BN.bn_is_odd len n in
let m0 = uint #t 0 -. bit0 in
let m1 = BN.bn_lt_mask len one n in
let m = m0 &. m1 in
pop_frame ();
m
let bn_precomp_r2_mod_n #t k nBits n res =
[@inline_let] let len = k.BN.len in
memset res (uint #t 0) len;
BN.bn_set_ith_bit len res nBits;
[@inline_let]
let spec h = S.bn_lshift1_mod_n (as_seq h n) in
let h0 = ST.get () in
loop1 h0 (2ul *! size (bits t) *! len -! nBits) res spec
(fun i ->
Loops.unfold_repeati (2 * bits t * v len - v nBits) (spec h0) (as_seq h0 res) (v i);
BN.add_mod_n n res res res
)
let bn_mont_precomp #t len precompr2 nBits n r2 =
precompr2 nBits n r2;
mod_inv_limb n.(0ul)
inline_for_extraction noextract
val bn_mont_reduction_f:
#t:limb_t
-> len:size_t{v len + v len <= max_size_t}
-> n:lbignum t len
-> nInv:(limb t)
-> j:size_t{v j < v len}
-> c:lbuffer (carry t) 1ul
-> res:lbignum t (len +! len) ->
Stack unit
(requires fun h ->
live h n /\ live h res /\ live h c /\
disjoint n res /\ disjoint n c /\ disjoint c res)
(ensures fun h0 _ h1 -> modifies (loc res |+| loc c) h0 h1 /\
(Seq.index (as_seq h1 c) 0, as_seq h1 res) ==
S.bn_mont_reduction_f (as_seq h0 n) nInv (v j) (Seq.index (as_seq h0 c) 0, as_seq h0 res)) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",
"Hacl.Spec.Bignum.Montgomery.fst.checked",
"Hacl.Spec.Bignum.fsti.checked",
"Hacl.Bignum.Definitions.fst.checked",
"Hacl.Bignum.Base.fst.checked",
"Hacl.Bignum.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": true,
"source_file": "Hacl.Bignum.Montgomery.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum",
"short_module": "SB"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "Lib.LoopCombinators",
"short_module": "Loops"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.ModInvLimb",
"short_module": null
},
{
"abbrev": true,
"full_module": "Hacl.Bignum",
"short_module": "BN"
},
{
"abbrev": true,
"full_module": "Hacl.Spec.Bignum.Montgomery",
"short_module": "S"
},
{
"abbrev": false,
"full_module": "Hacl.Bignum.Definitions",
"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.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Bignum",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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"
} | false |
len: Lib.IntTypes.size_t{Lib.IntTypes.v len + Lib.IntTypes.v len <= Lib.IntTypes.max_size_t} ->
n: Hacl.Bignum.Definitions.lbignum t len ->
nInv: Hacl.Bignum.Definitions.limb t ->
j: Lib.IntTypes.size_t{Lib.IntTypes.v j < Lib.IntTypes.v len} ->
c: Lib.Buffer.lbuffer (Hacl.Spec.Bignum.Base.carry t) 1ul ->
res: Hacl.Bignum.Definitions.lbignum t (len +! len)
-> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum.Definitions.limb_t",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.max_size_t",
"Hacl.Bignum.Definitions.lbignum",
"Hacl.Bignum.Definitions.limb",
"Prims.op_LessThan",
"Lib.Buffer.lbuffer",
"Hacl.Spec.Bignum.Base.carry",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.op_Plus_Bang",
"Lib.Sequence.eq_intro",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Lib.Sequence.upd",
"FStar.Seq.Base.index",
"Prims.unit",
"Lib.Sequence.lemma_update_sub",
"Lib.Sequence.sub",
"LowStar.Monotonic.Buffer.modifies_buffer_elim",
"LowStar.Buffer.trivial_preorder",
"LowStar.Buffer.gsub",
"Lib.IntTypes.op_Subtraction_Bang",
"Lib.Buffer.op_Bar_Plus_Bar",
"Lib.Buffer.loc",
"Prims._assert",
"Prims.eq2",
"Prims.int",
"Lib.Buffer.lbuffer_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Lib.Buffer.op_Array_Assignment",
"Hacl.Bignum.Base.addcarry_st",
"Lib.Buffer.op_Array_Access",
"Hacl.Bignum.bn_mul1_lshift_add_in_place",
"Lib.IntTypes.int_t",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Star_Dot"
] | [] | false | true | false | false | false | let bn_mont_reduction_f #t len n nInv j c res =
| let qj = nInv *. res.(j) in
let c1 = BN.bn_mul1_lshift_add_in_place len n qj (len +! len) j res in
let h0 = ST.get () in
let resb = sub res (len +! j) 1ul in
let res_j = res.(len +! j) in
c.(0ul) <- addcarry_st c.(0ul) c1 res_j resb;
let h1 = ST.get () in
let tmp = sub res (len +! j) 1ul in
B.modifies_buffer_elim (B.gsub #(limb t) res 0ul (len +! j)) (loc c |+| loc tmp) h0 h1;
assert (v (len +! j +! 1ul) + v (len +! len -! len -! j -! 1ul) == v (len +! len));
B.modifies_buffer_elim (B.gsub #(limb t) res (len +! j +! 1ul) (len -! j -! 1ul))
(loc c |+| loc tmp)
h0
h1;
LSeq.lemma_update_sub (as_seq h0 res)
(v len + v j)
1
(LSeq.sub (as_seq h1 res) (v len + v j) 1)
(as_seq h1 res);
LSeq.eq_intro (as_seq h1 res)
(LSeq.upd (as_seq h0 res) (v len + v j) (Seq.index (as_seq h1 res) (v len + v j))) | false |
Hacl.Impl.Exponentiation.Definitions.fst | Hacl.Impl.Exponentiation.Definitions.lsqr_st | val lsqr_st : a_t: Hacl.Impl.Exponentiation.Definitions.inttype_a ->
len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} ->
ctx_len: Lib.IntTypes.size_t ->
to: Hacl.Impl.Exponentiation.Definitions.to_comm_monoid a_t len ctx_len
-> Type0 | let lsqr_st
(a_t:inttype_a)
(len:size_t{v len > 0})
(ctx_len:size_t)
(to:to_comm_monoid a_t len ctx_len) =
ctx:lbuffer (uint_t a_t SEC) ctx_len
-> x:lbuffer (uint_t a_t SEC) len
-> xx:lbuffer (uint_t a_t SEC) len ->
Stack unit
(requires fun h ->
live h x /\ live h xx /\ live h ctx /\
disjoint x ctx /\ disjoint xx ctx /\ eq_or_disjoint x xx /\
to.linv (as_seq h x) /\ to.linv_ctx (as_seq h ctx))
(ensures fun h0 _ h1 -> modifies (loc xx) h0 h1 /\ to.linv (as_seq h1 xx) /\
to.refl (as_seq h1 xx) == to.comm_monoid.S.mul (refl (as_seq h0 x)) (refl (as_seq h0 x))) | {
"file_name": "code/bignum/Hacl.Impl.Exponentiation.Definitions.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 93,
"end_line": 81,
"start_col": 0,
"start_line": 67
} | module Hacl.Impl.Exponentiation.Definitions
open FStar.HyperStack
open FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
module ST = FStar.HyperStack.ST
module LSeq = Lib.Sequence
module S = Lib.Exponentiation.Definition
#reset-options "--z3rlimit 50 --fuel 0 --ifuel 0"
inline_for_extraction noextract
let inttype_a = t:inttype{t = U32 \/ t = U64}
inline_for_extraction noextract
class to_comm_monoid (a_t:inttype_a) (len:size_t{v len > 0}) (ctx_len:size_t) = {
a_spec: Type0;
comm_monoid: S.comm_monoid a_spec;
linv_ctx: x:LSeq.lseq (uint_t a_t SEC) (v ctx_len) -> Type0;
linv: x:LSeq.lseq (uint_t a_t SEC) (v len) -> Type0;
refl: x:LSeq.lseq (uint_t a_t SEC) (v len){linv x} -> GTot a_spec;
}
inline_for_extraction noextract
let lone_st
(a_t:inttype_a)
(len:size_t{v len > 0})
(ctx_len:size_t)
(to:to_comm_monoid a_t len ctx_len) =
ctx:lbuffer (uint_t a_t SEC) ctx_len
-> x:lbuffer (uint_t a_t SEC) len ->
Stack unit
(requires fun h ->
live h x /\ live h ctx /\ disjoint ctx x /\
to.linv_ctx (as_seq h ctx))
(ensures fun h0 _ h1 -> modifies (loc x) h0 h1 /\
to.linv (as_seq h1 x) /\
to.refl (as_seq h1 x) == to.comm_monoid.S.one)
inline_for_extraction noextract
let lmul_st
(a_t:inttype_a)
(len:size_t{v len > 0})
(ctx_len:size_t)
(to:to_comm_monoid a_t len ctx_len) =
ctx:lbuffer (uint_t a_t SEC) ctx_len
-> x:lbuffer (uint_t a_t SEC) len
-> y:lbuffer (uint_t a_t SEC) len
-> xy:lbuffer (uint_t a_t SEC) len ->
Stack unit
(requires fun h ->
live h x /\ live h y /\ live h xy /\ live h ctx /\
eq_or_disjoint x xy /\ eq_or_disjoint y xy /\ eq_or_disjoint x y /\
disjoint ctx x /\ disjoint ctx y /\ disjoint ctx xy /\
to.linv (as_seq h x) /\ to.linv (as_seq h y) /\ to.linv_ctx (as_seq h ctx))
(ensures fun h0 _ h1 -> modifies (loc xy) h0 h1 /\ to.linv (as_seq h1 xy) /\
to.refl (as_seq h1 xy) == to.comm_monoid.S.mul (to.refl (as_seq h0 x)) (to.refl (as_seq h0 y))) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Exponentiation.Definition.fsti.checked",
"Lib.Buffer.fsti.checked",
"FStar.Tactics.Typeclasses.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Exponentiation.Definitions.fst"
} | [
{
"abbrev": true,
"full_module": "Lib.Exponentiation.Definition",
"short_module": "S"
},
{
"abbrev": true,
"full_module": "Lib.Sequence",
"short_module": "LSeq"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"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.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Exponentiation",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Exponentiation",
"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
}
] | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 0,
"initial_ifuel": 0,
"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"
} | false |
a_t: Hacl.Impl.Exponentiation.Definitions.inttype_a ->
len: Lib.IntTypes.size_t{Lib.IntTypes.v len > 0} ->
ctx_len: Lib.IntTypes.size_t ->
to: Hacl.Impl.Exponentiation.Definitions.to_comm_monoid a_t len ctx_len
-> Type0 | Prims.Tot | [
"total"
] | [] | [
"Hacl.Impl.Exponentiation.Definitions.inttype_a",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_GreaterThan",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Hacl.Impl.Exponentiation.Definitions.to_comm_monoid",
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.SEC",
"Prims.unit",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"Lib.Buffer.live",
"Lib.Buffer.MUT",
"Lib.Buffer.disjoint",
"Lib.Buffer.eq_or_disjoint",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__linv",
"Lib.Buffer.as_seq",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__linv_ctx",
"Lib.Buffer.modifies",
"Lib.Buffer.loc",
"Prims.eq2",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__a_spec",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__refl",
"Lib.Exponentiation.Definition.__proj__Mkcomm_monoid__item__mul",
"Hacl.Impl.Exponentiation.Definitions.__proj__Mkto_comm_monoid__item__comm_monoid",
"Hacl.Impl.Exponentiation.Definitions.refl"
] | [] | false | false | false | false | true | let lsqr_st
(a_t: inttype_a)
(len: size_t{v len > 0})
(ctx_len: size_t)
(to: to_comm_monoid a_t len ctx_len)
=
|
ctx: lbuffer (uint_t a_t SEC) ctx_len ->
x: lbuffer (uint_t a_t SEC) len ->
xx: lbuffer (uint_t a_t SEC) len
-> Stack unit
(requires
fun h ->
live h x /\ live h xx /\ live h ctx /\ disjoint x ctx /\ disjoint xx ctx /\
eq_or_disjoint x xx /\ to.linv (as_seq h x) /\ to.linv_ctx (as_seq h ctx))
(ensures
fun h0 _ h1 ->
modifies (loc xx) h0 h1 /\ to.linv (as_seq h1 xx) /\
to.refl (as_seq h1 xx) == to.comm_monoid.S.mul (refl (as_seq h0 x)) (refl (as_seq h0 x))) | false |
|
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_empty | val read_empty:leaf_reader parse_empty | val read_empty:leaf_reader parse_empty | let read_empty : leaf_reader parse_empty = read_ret () | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 54,
"end_line": 450,
"start_col": 0,
"start_line": 450
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | LowParse.Low.Base.leaf_reader LowParse.Spec.Combinators.parse_empty | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Combinators.read_ret",
"Prims.unit"
] | [] | false | false | false | true | false | let read_empty:leaf_reader parse_empty =
| read_ret () | false |
Vale.X64.Lemmas.fsti | Vale.X64.Lemmas.eval_ins | val eval_ins (c: code) (s0: vale_state)
: Ghost (vale_state & fuel) (requires Ins? c) (ensures fun (sM, f0) -> eval_code c s0 f0 sM) | val eval_ins (c: code) (s0: vale_state)
: Ghost (vale_state & fuel) (requires Ins? c) (ensures fun (sM, f0) -> eval_code c s0 f0 sM) | let eval_ins (c:code) (s0:vale_state) : Ghost (vale_state & fuel)
(requires Ins? c)
(ensures fun (sM, f0) -> eval_code c s0 f0 sM)
=
reveal_opaque (`%BS.machine_eval_code_ins) BS.machine_eval_code_ins;
let f0 = 0 in
let (Some sM) = machine_eval_code c f0 (state_to_S s0) in
lemma_to_of sM;
(state_of_S sM, f0) | {
"file_name": "vale/code/arch/x64/Vale.X64.Lemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 21,
"end_line": 62,
"start_col": 0,
"start_line": 54
} | module Vale.X64.Lemmas
open FStar.Mul
open Vale.Arch.Heap
open Vale.Arch.HeapImpl
open Vale.Arch.HeapLemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.Bytes_Code_s
module BS = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
unfold let code = BS.code
unfold let codes = BS.codes
unfold let ocmp = BS.ocmp
unfold let fuel = nat
let cf (flags:Flags.t) : Flags.flag_val_t = Flags.sel fCarry flags
let overflow (flags:Flags.t) : Flags.flag_val_t = Flags.sel fOverflow flags
let update_cf (flags:Flags.t) (new_cf:bool) = Flags.upd fCarry (Some new_cf) flags
let update_of (flags:Flags.t) (new_of:bool) = Flags.upd fOverflow (Some new_of) flags
unfold let machine_state = BS.machine_state
unfold let machine_eval_code = BS.machine_eval_code
let rec code_modifies_ghost (c:code) : bool =
match c with
| Ins (Instr _ _ (BS.AnnotateGhost _)) -> true
| Ins _ -> false
| Block cs -> codes_modifies_ghost cs
| IfElse _ c1 c2 -> code_modifies_ghost c1 || code_modifies_ghost c2
| While _ c -> code_modifies_ghost c
and codes_modifies_ghost (cs:codes) : bool =
match cs with
| [] -> false
| c::cs -> code_modifies_ghost c || codes_modifies_ghost cs
let core_state (ignore_ghost:bool) (s:machine_state) : machine_state =
{s with
BS.ms_trace = [];
BS.ms_heap = if ignore_ghost then heap_ignore_ghost_machine s.BS.ms_heap else s.BS.ms_heap;
}
let state_eq_S (ignore_ghost:bool) (s1 s2:machine_state) =
machine_state_eq (core_state ignore_ghost s1) (core_state ignore_ghost s2)
let state_eq_opt (ignore_ghost:bool) (s1 s2:option BS.machine_state) =
match (s1, s2) with
| (Some s1, Some s2) -> state_eq_S ignore_ghost s1 s2
| _ -> s1 == s2
let eval_code (c:code) (s0:vale_state) (f0:fuel) (s1:vale_state) : Type0 =
state_eq_opt (code_modifies_ghost c) (machine_eval_code c f0 (state_to_S s0)) (Some (state_to_S s1)) | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Arch.HeapLemmas.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Lemmas.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "BS"
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"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
}
] | {
"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"
} | false | c: Vale.X64.Lemmas.code -> s0: Vale.X64.State.vale_state
-> Prims.Ghost (Vale.X64.State.vale_state * Vale.X64.Lemmas.fuel) | Prims.Ghost | [] | [] | [
"Vale.X64.Lemmas.code",
"Vale.X64.State.vale_state",
"Vale.X64.Machine_Semantics_s.machine_state",
"FStar.Pervasives.Native.Mktuple2",
"Vale.X64.Lemmas.fuel",
"Vale.X64.StateLemmas.state_of_S",
"Prims.unit",
"Vale.X64.StateLemmas.lemma_to_of",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.option",
"Vale.X64.Lemmas.machine_eval_code",
"Vale.X64.StateLemmas.state_to_S",
"Prims.int",
"FStar.Pervasives.reveal_opaque",
"Vale.X64.Machine_Semantics_s.ins",
"Vale.X64.Machine_Semantics_s.machine_eval_code_ins",
"Prims.b2t",
"Vale.X64.Machine_s.uu___is_Ins",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Lemmas.eval_code"
] | [] | false | false | false | false | false | let eval_ins (c: code) (s0: vale_state)
: Ghost (vale_state & fuel) (requires Ins? c) (ensures fun (sM, f0) -> eval_code c s0 f0 sM) =
| reveal_opaque (`%BS.machine_eval_code_ins) BS.machine_eval_code_ins;
let f0 = 0 in
let Some sM = machine_eval_code c f0 (state_to_S s0) in
lemma_to_of sM;
(state_of_S sM, f0) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_empty | val validate_empty: Prims.unit -> Tot (validator parse_empty) | val validate_empty: Prims.unit -> Tot (validator parse_empty) | let validate_empty () : Tot (validator parse_empty)
= validate_ret () | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 17,
"end_line": 421,
"start_col": 0,
"start_line": 420
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | _: Prims.unit -> LowParse.Low.Base.validator LowParse.Spec.Combinators.parse_empty | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"LowParse.Low.Combinators.validate_ret",
"LowParse.Low.Base.validator",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_empty"
] | [] | false | false | false | true | false | let validate_empty () : Tot (validator parse_empty) =
| validate_ret () | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_false | val read_false:leaf_reader parse_false | val read_false:leaf_reader parse_false | let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called" | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 61,
"end_line": 454,
"start_col": 0,
"start_line": 453
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | LowParse.Low.Base.leaf_reader LowParse.Spec.Combinators.parse_false | Prims.Tot | [
"total"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Failure.failwith",
"Prims.squash",
"Prims.l_False"
] | [] | false | false | false | true | false | let read_false:leaf_reader parse_false =
| fun #rrel #rel sl pos -> LowStar.Failure.failwith "read_false: should not be called" | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.clens_synth | val clens_synth (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1)) : Tot (clens t1 t2) | val clens_synth (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1)) : Tot (clens t1 t2) | let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
} | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 526,
"start_col": 0,
"start_line": 511
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | f: (_: t1 -> Prims.GTot t2) -> g: (_: t2 -> Prims.GTot t1) -> LowParse.Low.Base.Spec.clens t1 t2 | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.Mkclens",
"Prims.l_True",
"LowParse.Low.Base.Spec.clens"
] | [] | false | false | false | false | false | let clens_synth (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1)) : Tot (clens t1 t2) =
| { clens_cond = (fun (x: t1) -> True); clens_get = (fun (x: t1) -> f x) } | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.clens_snd | val clens_snd (t1 t2: Type) : Tot (clens (t1 & t2) t2) | val clens_snd (t1 t2: Type) : Tot (clens (t1 & t2) t2) | let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
} | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 684,
"start_col": 0,
"start_line": 671
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | t1: Type -> t2: Type -> LowParse.Low.Base.Spec.clens (t1 * t2) t2 | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.Mkclens",
"FStar.Pervasives.Native.tuple2",
"Prims.l_True",
"FStar.Pervasives.Native.snd",
"LowParse.Low.Base.Spec.clens"
] | [] | false | false | false | true | false | let clens_snd (t1 t2: Type) : Tot (clens (t1 & t2) t2) =
| { clens_cond = (fun (x: (t1 & t2)) -> True); clens_get = snd } | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.clens_synth_inv | val clens_synth_inv (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1)) : Tot (clens t2 t1) | val clens_synth_inv (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1)) : Tot (clens t2 t1) | let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
} | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 599,
"start_col": 0,
"start_line": 584
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | f: (_: t1 -> Prims.GTot t2) -> g: (_: t2 -> Prims.GTot t1) -> LowParse.Low.Base.Spec.clens t2 t1 | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.Mkclens",
"Prims.l_True",
"LowParse.Low.Base.Spec.clens"
] | [] | false | false | false | false | false | let clens_synth_inv (#t1 #t2: Type) (f: (t1 -> GTot t2)) (g: (t2 -> GTot t1)) : Tot (clens t2 t1) =
| { clens_cond = (fun (x: t2) -> True); clens_get = (fun (x: t2) -> g x) } | false |
Vale.X64.Lemmas.fsti | Vale.X64.Lemmas.code_modifies_ghost | val code_modifies_ghost (c: code) : bool | val code_modifies_ghost (c: code) : bool | let rec code_modifies_ghost (c:code) : bool =
match c with
| Ins (Instr _ _ (BS.AnnotateGhost _)) -> true
| Ins _ -> false
| Block cs -> codes_modifies_ghost cs
| IfElse _ c1 c2 -> code_modifies_ghost c1 || code_modifies_ghost c2
| While _ c -> code_modifies_ghost c
and codes_modifies_ghost (cs:codes) : bool =
match cs with
| [] -> false
| c::cs -> code_modifies_ghost c || codes_modifies_ghost cs | {
"file_name": "vale/code/arch/x64/Vale.X64.Lemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 35,
"start_col": 0,
"start_line": 25
} | module Vale.X64.Lemmas
open FStar.Mul
open Vale.Arch.Heap
open Vale.Arch.HeapImpl
open Vale.Arch.HeapLemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.Bytes_Code_s
module BS = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
unfold let code = BS.code
unfold let codes = BS.codes
unfold let ocmp = BS.ocmp
unfold let fuel = nat
let cf (flags:Flags.t) : Flags.flag_val_t = Flags.sel fCarry flags
let overflow (flags:Flags.t) : Flags.flag_val_t = Flags.sel fOverflow flags
let update_cf (flags:Flags.t) (new_cf:bool) = Flags.upd fCarry (Some new_cf) flags
let update_of (flags:Flags.t) (new_of:bool) = Flags.upd fOverflow (Some new_of) flags
unfold let machine_state = BS.machine_state
unfold let machine_eval_code = BS.machine_eval_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Arch.HeapLemmas.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Lemmas.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "BS"
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"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
}
] | {
"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"
} | false | c: Vale.X64.Lemmas.code -> Prims.bool | Prims.Tot | [
"total"
] | [
"code_modifies_ghost",
"codes_modifies_ghost"
] | [
"Vale.X64.Lemmas.code",
"Vale.X64.Instruction_s.instr_t_record",
"Vale.X64.Instruction_s.instr_operands_t",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__outs",
"Vale.X64.Instruction_s.__proj__InstrTypeRecord__item__args",
"Vale.X64.Machine_Semantics_s.equals_instr",
"Vale.X64.Instruction_s.InstrTypeRecord",
"Prims.Nil",
"Vale.X64.Instruction_s.instr_out",
"Vale.X64.Instruction_s.instr_operand",
"Vale.X64.Instruction_s.PreserveFlags",
"Vale.X64.Instructions_s.ins_Ghost",
"Vale.X64.Bytes_Code_s.instruction_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Vale.X64.Machine_s.precode",
"Vale.X64.Bytes_Code_s.ocmp",
"Vale.X64.Lemmas.codes_modifies_ghost",
"Prims.op_BarBar",
"Vale.X64.Lemmas.code_modifies_ghost",
"Prims.bool"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec code_modifies_ghost (c: code) : bool =
| match c with
| Ins (Instr _ _ (BS.AnnotateGhost _)) -> true
| Ins _ -> false
| Block cs -> codes_modifies_ghost cs
| IfElse _ c1 c2 -> code_modifies_ghost c1 || code_modifies_ghost c2
| While _ c -> code_modifies_ghost c | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.clens_fst | val clens_fst (t1 t2: Type) : Tot (clens (t1 & t2) t1) | val clens_fst (t1 t2: Type) : Tot (clens (t1 & t2) t1) | let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
} | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 1,
"end_line": 669,
"start_col": 0,
"start_line": 656
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | t1: Type -> t2: Type -> LowParse.Low.Base.Spec.clens (t1 * t2) t1 | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.Mkclens",
"FStar.Pervasives.Native.tuple2",
"Prims.l_True",
"FStar.Pervasives.Native.fst",
"LowParse.Low.Base.Spec.clens"
] | [] | false | false | false | true | false | let clens_fst (t1 t2: Type) : Tot (clens (t1 & t2) t1) =
| { clens_cond = (fun (x: (t1 & t2)) -> True); clens_get = fst } | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_fst_then | val gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k': parser_kind)
(#t': Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' ((clens_fst _ _) `clens_compose` cl)) | val gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k': parser_kind)
(#t': Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' ((clens_fst _ _) `clens_compose` cl)) | let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 45,
"end_line": 741,
"start_col": 0,
"start_line": 727
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
g: LowParse.Low.Base.Spec.gaccessor p1 p' cl ->
p2: LowParse.Spec.Base.parser k2 t2 ->
u645: Prims.squash Prims.unit
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.Combinators.nondep_then p1 p2)
p'
(LowParse.Low.Base.Spec.clens_compose (LowParse.Low.Combinators.clens_fst t1 t2) cl) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"Prims.squash",
"Prims.unit",
"LowParse.Low.Base.Spec.gaccessor_compose",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Combinators.clens_fst",
"LowParse.Low.Combinators.gaccessor_fst",
"LowParse.Low.Base.Spec.clens_compose"
] | [] | false | false | false | false | false | let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k': parser_kind)
(#t': Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' ((clens_fst _ _) `clens_compose` cl)) =
| (gaccessor_fst p1 u p2) `gaccessor_compose` g | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_then_snd | val gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` (clens_snd _ _))) | val gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` (clens_snd _ _))) | let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _ | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 41,
"end_line": 845,
"start_col": 0,
"start_line": 832
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input ) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | g: LowParse.Low.Base.Spec.gaccessor p0 (LowParse.Spec.Combinators.nondep_then p1 p2) cl
-> LowParse.Low.Base.Spec.gaccessor p0
p2
(LowParse.Low.Base.Spec.clens_compose cl (LowParse.Low.Combinators.clens_snd t1 t2)) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"FStar.Pervasives.Native.tuple2",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Base.Spec.gaccessor_compose",
"LowParse.Low.Combinators.clens_snd",
"LowParse.Low.Combinators.gaccessor_snd",
"LowParse.Low.Base.Spec.clens_compose"
] | [] | false | false | false | false | false | let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` (clens_snd _ _))) =
| g `gaccessor_compose` (gaccessor_snd _ _) | false |
Vale.X64.Lemmas.fsti | Vale.X64.Lemmas.codes_modifies_ghost | val codes_modifies_ghost (cs: codes) : bool | val codes_modifies_ghost (cs: codes) : bool | let rec code_modifies_ghost (c:code) : bool =
match c with
| Ins (Instr _ _ (BS.AnnotateGhost _)) -> true
| Ins _ -> false
| Block cs -> codes_modifies_ghost cs
| IfElse _ c1 c2 -> code_modifies_ghost c1 || code_modifies_ghost c2
| While _ c -> code_modifies_ghost c
and codes_modifies_ghost (cs:codes) : bool =
match cs with
| [] -> false
| c::cs -> code_modifies_ghost c || codes_modifies_ghost cs | {
"file_name": "vale/code/arch/x64/Vale.X64.Lemmas.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 61,
"end_line": 35,
"start_col": 0,
"start_line": 25
} | module Vale.X64.Lemmas
open FStar.Mul
open Vale.Arch.Heap
open Vale.Arch.HeapImpl
open Vale.Arch.HeapLemmas
open Vale.X64.Machine_s
open Vale.X64.State
open Vale.X64.StateLemmas
open Vale.X64.Bytes_Code_s
module BS = Vale.X64.Machine_Semantics_s
module Map16 = Vale.Lib.Map16
unfold let code = BS.code
unfold let codes = BS.codes
unfold let ocmp = BS.ocmp
unfold let fuel = nat
let cf (flags:Flags.t) : Flags.flag_val_t = Flags.sel fCarry flags
let overflow (flags:Flags.t) : Flags.flag_val_t = Flags.sel fOverflow flags
let update_cf (flags:Flags.t) (new_cf:bool) = Flags.upd fCarry (Some new_cf) flags
let update_of (flags:Flags.t) (new_of:bool) = Flags.upd fOverflow (Some new_of) flags
unfold let machine_state = BS.machine_state
unfold let machine_eval_code = BS.machine_eval_code | {
"checked_file": "/",
"dependencies": [
"Vale.X64.StateLemmas.fsti.checked",
"Vale.X64.State.fsti.checked",
"Vale.X64.Machine_Semantics_s.fst.checked",
"Vale.X64.Machine_s.fst.checked",
"Vale.X64.Flags.fsti.checked",
"Vale.X64.Bytes_Code_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Arch.HeapLemmas.fsti.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Vale.X64.Lemmas.fsti"
} | [
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": true,
"full_module": "Vale.X64.Machine_Semantics_s",
"short_module": "BS"
},
{
"abbrev": false,
"full_module": "Vale.X64.Bytes_Code_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.StateLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.State",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapLemmas",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64",
"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
}
] | {
"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"
} | false | cs: Vale.X64.Lemmas.codes -> Prims.bool | Prims.Tot | [
"total"
] | [
"code_modifies_ghost",
"codes_modifies_ghost"
] | [
"Vale.X64.Lemmas.codes",
"Vale.X64.Bytes_Code_s.code_t",
"Vale.X64.Machine_Semantics_s.instr_annotation",
"Prims.list",
"Prims.op_BarBar",
"Vale.X64.Lemmas.code_modifies_ghost",
"Vale.X64.Lemmas.codes_modifies_ghost",
"Prims.bool"
] | [
"mutual recursion"
] | false | false | false | true | false | let rec codes_modifies_ghost (cs: codes) : bool =
| match cs with
| [] -> false
| c :: cs -> code_modifies_ghost c || codes_modifies_ghost cs | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.accessor_fst_then | val accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k': parser_kind)
(#t': Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u)) | val accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k': parser_kind)
(#t': Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u)) | let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 45,
"end_line": 905,
"start_col": 0,
"start_line": 890
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
a: LowParse.Low.Base.accessor g ->
p2: LowParse.Spec.Base.parser k2 t2 ->
u825: Prims.squash Prims.unit
-> LowParse.Low.Base.accessor (LowParse.Low.Combinators.gaccessor_fst_then g p2 u825) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Low.Base.accessor",
"Prims.squash",
"Prims.unit",
"LowParse.Low.Base.accessor_compose",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Combinators.clens_fst",
"LowParse.Low.Combinators.gaccessor_fst",
"LowParse.Low.Combinators.accessor_fst",
"LowParse.Low.Base.Spec.clens_compose",
"LowParse.Low.Combinators.gaccessor_fst_then"
] | [] | false | false | false | false | false | let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k': parser_kind)
(#t': Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u)) =
| accessor_compose (accessor_fst p1 u p2) a u | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.accessor_then_snd | val accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g)) | val accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g)) | let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) () | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 961,
"start_col": 0,
"start_line": 946
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | a: LowParse.Low.Base.accessor g -> j1: LowParse.Low.Base.jumper p1
-> LowParse.Low.Base.accessor (LowParse.Low.Combinators.gaccessor_then_snd g) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"FStar.Pervasives.Native.tuple2",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Base.accessor",
"LowParse.Low.Base.jumper",
"LowParse.Low.Base.accessor_compose",
"LowParse.Low.Combinators.clens_snd",
"LowParse.Low.Combinators.gaccessor_snd",
"LowParse.Low.Combinators.accessor_snd",
"LowParse.Low.Base.Spec.clens_compose",
"LowParse.Low.Combinators.gaccessor_then_snd"
] | [] | false | false | false | false | false | let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g)) =
| accessor_compose a (accessor_snd j1 p2) () | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_dtuple2 | val read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(r2: (x: t1 -> Tot (leaf_reader (p2 x))))
: Tot (leaf_reader (parse_dtuple2 p1 p2)) | val read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(r2: (x: t1 -> Tot (leaf_reader (p2 x))))
: Tot (leaf_reader (parse_dtuple2 p1 p2)) | let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 390,
"start_col": 0,
"start_line": 373
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
v1: LowParse.Low.Base.jumper p1 ->
r1: LowParse.Low.Base.leaf_reader p1 ->
r2: (x: t1 -> LowParse.Low.Base.leaf_reader (p2 x))
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Combinators.parse_dtuple2 p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"LowParse.Low.Base.leaf_reader",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.Mkdtuple2",
"Prims.dtuple2",
"Prims.unit",
"LowParse.Low.Combinators.valid_dtuple2",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_dtuple2"
] | [] | false | false | false | false | false | let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(r2: (x: t1 -> Tot (leaf_reader (p2 x))))
: Tot (leaf_reader (parse_dtuple2 p1 p2)) =
| fun #_ #_ sl pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_empty | val jump_empty:jumper parse_empty | val jump_empty:jumper parse_empty | let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul () | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 39,
"end_line": 433,
"start_col": 0,
"start_line": 432
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | LowParse.Low.Base.jumper LowParse.Spec.Combinators.parse_empty | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.jump_constant_size",
"LowParse.Spec.Combinators.parse_ret_kind",
"Prims.unit",
"LowParse.Spec.Combinators.parse_empty",
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | true | false | let jump_empty:jumper parse_empty =
| jump_constant_size parse_empty 0ul () | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_nondep_then | val jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2': jumper p2)
: Tot (jumper (nondep_then p1 p2)) | val jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2': jumper p2)
: Tot (jumper (nondep_then p1 p2)) | let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 105,
"start_col": 0,
"start_line": 91
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | p1': LowParse.Low.Base.jumper p1 -> p2': LowParse.Low.Base.jumper p2
-> LowParse.Low.Base.jumper (LowParse.Spec.Combinators.nondep_then p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Combinators.valid_nondep_then",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then"
] | [] | false | false | false | false | false | let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2': jumper p2)
: Tot (jumper (nondep_then p1 p2)) =
| fun (#rrel: _) (#rel: _) (input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_synth | val jump_synth
(#k: parser_kind)
(#t1 #t2: Type)
(#p1: parser k t1)
(p1': jumper p1)
(f2: (t1 -> GTot t2))
(u: unit{synth_injective f2})
: Tot (jumper (parse_synth p1 f2)) | val jump_synth
(#k: parser_kind)
(#t1 #t2: Type)
(#p1: parser k t1)
(p1': jumper p1)
(f2: (t1 -> GTot t2))
(u: unit{synth_injective f2})
: Tot (jumper (parse_synth p1 f2)) | let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 15,
"end_line": 267,
"start_col": 0,
"start_line": 252
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1': LowParse.Low.Base.jumper p1 ->
f2: (_: t1 -> Prims.GTot t2) ->
u262: u264: Prims.unit{LowParse.Spec.Combinators.synth_injective f2}
-> LowParse.Low.Base.jumper (LowParse.Spec.Combinators.parse_synth p1 f2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Combinators.valid_synth",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.parse_synth"
] | [] | false | false | false | false | false | let jump_synth
(#k: parser_kind)
(#t1 #t2: Type)
(#p1: parser k t1)
(p1': jumper p1)
(f2: (t1 -> GTot t2))
(u: unit{synth_injective f2})
: Tot (jumper (parse_synth p1 f2)) =
| fun (#rrel: _) (#rel: _) (input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_synth h p1 f2 input pos in
p1' input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.valid_synth_intro | val valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (synth_injective f2 /\ valid p1 h input pos))
(ensures
(valid_content_pos (parse_synth p1 f2)
h
input
pos
(f2 (contents p1 h input pos))
(get_valid_pos p1 h input pos))) | val valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (synth_injective f2 /\ valid p1 h input pos))
(ensures
(valid_content_pos (parse_synth p1 f2)
h
input
pos
(f2 (contents p1 h input pos))
(get_valid_pos p1 h input pos))) | let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 31,
"end_line": 231,
"start_col": 0,
"start_line": 213
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
h: FStar.Monotonic.HyperStack.mem ->
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.Combinators.synth_injective f2 /\ LowParse.Low.Base.Spec.valid p1 h input pos)
(ensures
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Combinators.parse_synth p1 f2)
h
input
pos
(f2 (LowParse.Low.Base.Spec.contents p1 h input pos))
(LowParse.Low.Base.Spec.get_valid_pos p1 h input pos)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Combinators.valid_synth",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (synth_injective f2 /\ valid p1 h input pos))
(ensures
(valid_content_pos (parse_synth p1 f2)
h
input
pos
(f2 (contents p1 h input pos))
(get_valid_pos p1 h input pos))) =
| valid_synth h p1 f2 input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_synth | val validate_synth
(#k: parser_kind)
(#t1 #t2: Type)
(#p1: parser k t1)
(p1': validator p1)
(f2: (t1 -> GTot t2))
(u: unit{synth_injective f2})
: Tot (validator (parse_synth p1 f2)) | val validate_synth
(#k: parser_kind)
(#t1 #t2: Type)
(#p1: parser k t1)
(p1': validator p1)
(f2: (t1 -> GTot t2))
(u: unit{synth_injective f2})
: Tot (validator (parse_synth p1 f2)) | let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 15,
"end_line": 249,
"start_col": 0,
"start_line": 234
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1': LowParse.Low.Base.validator p1 ->
f2: (_: t1 -> Prims.GTot t2) ->
u248: u250: Prims.unit{LowParse.Spec.Combinators.synth_injective f2}
-> LowParse.Low.Base.validator (LowParse.Spec.Combinators.parse_synth p1 f2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.Combinators.valid_synth",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.parse_synth"
] | [] | false | false | false | false | false | let validate_synth
(#k: parser_kind)
(#t1 #t2: Type)
(#p1: parser k t1)
(p1': validator p1)
(f2: (t1 -> GTot t2))
(u: unit{synth_injective f2})
: Tot (validator (parse_synth p1 f2)) =
| fun (#rrel: _) (#rel: _) (input: slice rrel rel) pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_nondep_then | val validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2': validator p2)
: Tot (validator (nondep_then p1 p2)) | val validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2': validator p2)
: Tot (validator (nondep_then p1 p2)) | let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 18,
"end_line": 88,
"start_col": 0,
"start_line": 67
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | p1': LowParse.Low.Base.validator p1 -> p2': LowParse.Low.Base.validator p2
-> LowParse.Low.Base.validator (LowParse.Spec.Combinators.nondep_then p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.is_error",
"Prims.bool",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"LowParse.Low.Combinators.valid_nondep_then",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then"
] | [] | false | false | false | false | false | let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2': validator p2)
: Tot (validator (nondep_then p1 p2)) =
| fun (#rrel: _) (#rel: _) (input: slice rrel rel) pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then pos1
else
[@@ inline_let ]let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_dtuple2 | val validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(v2: (x: t1 -> Tot (validator (p2 x))))
: Tot (validator (parse_dtuple2 p1 p2)) | val validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(v2: (x: t1 -> Tot (validator (p2 x))))
: Tot (validator (parse_dtuple2 p1 p2)) | let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 19,
"end_line": 329,
"start_col": 0,
"start_line": 306
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
v1: LowParse.Low.Base.validator p1 ->
r1: LowParse.Low.Base.leaf_reader p1 ->
v2: (x: t1 -> LowParse.Low.Base.validator (p2 x))
-> LowParse.Low.Base.validator (LowParse.Spec.Combinators.parse_dtuple2 p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"LowParse.Low.Base.leaf_reader",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.is_error",
"Prims.bool",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"LowParse.Low.Combinators.valid_dtuple2",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.and_then_kind",
"Prims.dtuple2",
"LowParse.Spec.Combinators.parse_dtuple2"
] | [] | false | false | false | false | false | let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(v2: (x: t1 -> Tot (validator (p2 x))))
: Tot (validator (parse_dtuple2 p1 p2)) =
| fun (#rrel: _) (#rel: _) (input: slice rrel rel) pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then pos1
else
let x = r1 input (uint64_to_uint32 pos) in
[@@ inline_let ]let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_ret | val read_ret (#t: Type) (v: t) : Tot (leaf_reader (parse_ret v)) | val read_ret (#t: Type) (v: t) : Tot (leaf_reader (parse_ret v)) | let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 447,
"start_col": 0,
"start_line": 440
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | v: t -> LowParse.Low.Base.leaf_reader (LowParse.Spec.Combinators.parse_ret v) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.leaf_reader"
] | [] | false | false | false | false | false | let read_ret (#t: Type) (v: t) : Tot (leaf_reader (parse_ret v)) =
| fun #rrel #rel sl pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_facts (parse_ret v) h sl pos in
v | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_nondep_then | val read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2)) | val read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2)) | let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 10,
"end_line": 125,
"start_col": 0,
"start_line": 108
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1': LowParse.Low.Base.jumper p1 ->
r1: LowParse.Low.Base.leaf_reader p1 ->
r2: LowParse.Low.Base.leaf_reader p2
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Combinators.nondep_then p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"LowParse.Low.Base.leaf_reader",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Prims.unit",
"LowParse.Low.Combinators.valid_nondep_then",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then"
] | [] | false | false | false | false | false | let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1': jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2)) =
| fun #_ #_ sl pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_dtuple2_constant_size_dsnd | val jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(sz: U32.t{U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low})
: Tot (jumper (parse_dtuple2 p1 p2)) | val jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(sz: U32.t{U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low})
: Tot (jumper (parse_dtuple2 p1 p2)) | let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 66,
"end_line": 370,
"start_col": 0,
"start_line": 353
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
v1: LowParse.Low.Base.jumper p1 ->
p2: (x: t1 -> LowParse.Spec.Base.parser k2 (t2 x)) ->
sz:
FStar.UInt32.t
{ FStar.UInt32.v sz == Mkparser_kind'?.parser_kind_low k2 /\
Mkparser_kind'?.parser_kind_high k2 ==
FStar.Pervasives.Native.Some (Mkparser_kind'?.parser_kind_low k2) }
-> LowParse.Low.Base.jumper (LowParse.Spec.Combinators.parse_dtuple2 p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Pervasives.Native.option",
"Prims.nat",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"FStar.Pervasives.Native.Some",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"LowParse.Low.Base.jump_constant_size'",
"LowParse.Low.Base.Spec.contents",
"Prims.unit",
"FStar.Ghost.reveal",
"LowParse.Low.Base.Spec.valid_facts",
"FStar.Ghost.erased",
"FStar.Ghost.hide",
"LowParse.Low.Combinators.valid_dtuple2",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.and_then_kind",
"Prims.dtuple2",
"LowParse.Spec.Combinators.parse_dtuple2"
] | [] | false | false | false | false | false | let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(sz: U32.t{U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low})
: Tot (jumper (parse_dtuple2 p1 p2)) =
| fun (#rrel: _) (#rel: _) (input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@@ inline_let ]let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@@ inline_let ]let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.valid_synth | val valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (live_slice h input /\ synth_injective f2))
(ensures
((valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==>
(valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2)
h
input
pos
(f2 (contents p1 h input pos))
(get_valid_pos p1 h input pos)))) | val valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (live_slice h input /\ synth_injective f2))
(ensures
((valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==>
(valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2)
h
input
pos
(f2 (contents p1 h input pos))
(get_valid_pos p1 h input pos)))) | let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 61,
"end_line": 211,
"start_col": 0,
"start_line": 189
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
h: FStar.Monotonic.HyperStack.mem ->
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires LowParse.Slice.live_slice h input /\ LowParse.Spec.Combinators.synth_injective f2)
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.Combinators.parse_synth p1 f2) h input pos \/
LowParse.Low.Base.Spec.valid p1 h input pos ==>
LowParse.Low.Base.Spec.valid p1 h input pos /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Combinators.parse_synth p1 f2)
h
input
pos
(f2 (LowParse.Low.Base.Spec.contents p1 h input pos))
(LowParse.Low.Base.Spec.get_valid_pos p1 h input pos)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Slice.bytes_of_slice_from",
"Prims.bool",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Combinators.parse_synth",
"Prims.l_and",
"LowParse.Slice.live_slice",
"LowParse.Spec.Combinators.synth_injective",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(input: slice rrel rel)
(pos: U32.t)
: Lemma (requires (live_slice h input /\ synth_injective f2))
(ensures
((valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==>
(valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2)
h
input
pos
(f2 (contents p1 h input pos))
(get_valid_pos p1 h input pos)))) =
| valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.serialize32_dtuple2 | val serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(#s2: (x: t1 -> Tot (serializer (p2 x))))
(s2': (x: t1 -> serializer32 (s2 x)))
: Tot (serializer32 (serialize_dtuple2 s1 s2)) | val serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(#s2: (x: t1 -> Tot (serializer (p2 x))))
(s2': (x: t1 -> serializer32 (s2 x)))
: Tot (serializer32 (serialize_dtuple2 s1 s2)) | let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 56,
"end_line": 410,
"start_col": 0,
"start_line": 393
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
s1':
LowParse.Low.Base.serializer32 s1
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s2': (x: t1 -> LowParse.Low.Base.serializer32 (s2 x))
-> LowParse.Low.Base.serializer32 (LowParse.Spec.Combinators.serialize_dtuple2 s1 s2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.serializer32",
"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",
"Prims.dtuple2",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowParse.Low.Combinators.serialize32_nondep_then_aux",
"Prims.unit",
"LowParse.Spec.Combinators.serialize_dtuple2_eq",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_dtuple2",
"LowParse.Spec.Combinators.serialize_dtuple2"
] | [] | false | false | false | false | false | let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: (t1 -> Tot Type))
(#p2: (x: t1 -> Tot (parser k2 (t2 x))))
(#s2: (x: t1 -> Tot (serializer (p2 x))))
(s2': (x: t1 -> serializer32 (s2 x)))
: Tot (serializer32 (serialize_dtuple2 s1 s2)) =
| fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@@ inline_let ]let _ = serialize_dtuple2_eq s1 s2 x in
match x with | (| x1 , x2 |) -> serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_ret | val validate_ret (#t: Type) (v: t) : Tot (validator (parse_ret v)) | val validate_ret (#t: Type) (v: t) : Tot (validator (parse_ret v)) | let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL () | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 51,
"end_line": 417,
"start_col": 0,
"start_line": 413
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | v: t -> LowParse.Low.Base.validator (LowParse.Spec.Combinators.parse_ret v) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.validate_total_constant_size",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"FStar.UInt64.__uint_to_t",
"LowParse.Low.Base.validator"
] | [] | false | false | false | false | false | let validate_ret (#t: Type) (v: t) : Tot (validator (parse_ret v)) =
| validate_total_constant_size (parse_ret v) 0uL () | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.valid_nondep_then_intro | val valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures
((let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2)
h
s
pos
(contents p1 h s pos, contents p2 h s pos1)
(get_valid_pos p2 h s pos1)))) | val valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures
((let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2)
h
s
pos
(contents p1 h s pos, contents p2 h s pos1)
(get_valid_pos p2 h s pos1)))) | let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 33,
"end_line": 64,
"start_col": 0,
"start_line": 47
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
h: FStar.Monotonic.HyperStack.mem ->
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p1 h s pos /\
LowParse.Low.Base.Spec.valid p2 h s (LowParse.Low.Base.Spec.get_valid_pos p1 h s pos))
(ensures
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos p1 h s pos in
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Combinators.nondep_then p1 p2)
h
s
pos
(LowParse.Low.Base.Spec.contents p1 h s pos,
LowParse.Low.Base.Spec.contents p2 h s pos1)
(LowParse.Low.Base.Spec.get_valid_pos p2 h s pos1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Combinators.valid_nondep_then",
"Prims.unit",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures
((let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2)
h
s
pos
(contents p1 h s pos, contents p2 h s pos1)
(get_valid_pos p2 h s pos1)))) =
| valid_nondep_then h p1 p2 s pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.serialize32_nondep_then | val serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2)) | val serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2)) | let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 49,
"end_line": 187,
"start_col": 0,
"start_line": 171
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
s1':
LowParse.Low.Base.serializer32 s1
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
s2': LowParse.Low.Base.serializer32 s2
-> LowParse.Low.Base.serializer32 (LowParse.Spec.Combinators.serialize_nondep_then s1 s2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.serializer32",
"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",
"FStar.Pervasives.Native.tuple2",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowParse.Low.Combinators.serialize32_nondep_then_aux",
"Prims.unit",
"LowParse.Spec.Combinators.serialize_nondep_then_eq",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Spec.Combinators.serialize_nondep_then"
] | [] | false | false | false | false | false | let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1 {k1.parser_kind_subkind == Some ParserStrong})
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2)) =
| fun x #rrel #rel b pos ->
[@@ inline_let ]let x1, x2 = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_dtuple2 | val jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(v2: (x: t1 -> Tot (jumper (p2 x))))
: Tot (jumper (parse_dtuple2 p1 p2)) | val jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(v2: (x: t1 -> Tot (jumper (p2 x))))
: Tot (jumper (parse_dtuple2 p1 p2)) | let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 17,
"end_line": 350,
"start_col": 0,
"start_line": 332
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
v1: LowParse.Low.Base.jumper p1 ->
r1: LowParse.Low.Base.leaf_reader p1 ->
v2: (x: t1 -> LowParse.Low.Base.jumper (p2 x))
-> LowParse.Low.Base.jumper (LowParse.Spec.Combinators.parse_dtuple2 p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"LowParse.Low.Base.leaf_reader",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.Combinators.valid_dtuple2",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.and_then_kind",
"Prims.dtuple2",
"LowParse.Spec.Combinators.parse_dtuple2"
] | [] | false | false | false | false | false | let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(#p2: (x: t1 -> parser k2 (t2 x)))
(v2: (x: t1 -> Tot (jumper (p2 x))))
: Tot (jumper (parse_dtuple2 p1 p2)) =
| fun (#rrel: _) (#rel: _) (input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@@ inline_let ]let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_fst | val gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _)) | val gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _)) | let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 25,
"end_line": 712,
"start_col": 0,
"start_line": 702
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k1 t1 ->
sq: Prims.squash Prims.unit ->
p2: LowParse.Spec.Base.parser k2 t2
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.Combinators.nondep_then p1 p2)
p1
(LowParse.Low.Combinators.clens_fst t1 t2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.squash",
"Prims.unit",
"LowParse.Low.Combinators.gaccessor_fst'",
"LowParse.Low.Base.Spec.gaccessor_prop_equiv",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Combinators.clens_fst",
"LowParse.Low.Base.Spec.gaccessor"
] | [] | false | false | false | false | false | let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _)) =
| gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_false | val validate_false: Prims.unit -> Tot (validator parse_false) | val validate_false: Prims.unit -> Tot (validator parse_false) | let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 25,
"end_line": 429,
"start_col": 0,
"start_line": 424
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | _: Prims.unit -> LowParse.Low.Base.validator LowParse.Spec.Combinators.parse_false | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.validator_error_generic",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Combinators.parse_false_kind",
"Prims.squash",
"Prims.l_False",
"LowParse.Spec.Combinators.parse_false",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.validator"
] | [] | false | false | false | true | false | let validate_false () : Tot (validator parse_false) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.serialize32_ret | val serialize32_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer32 (serialize_ret v v_unique)) | val serialize32_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer32 (serialize_ret v v_unique)) | let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 24,
"end_line": 462,
"start_col": 0,
"start_line": 457
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | v: t -> v_unique: (v': t -> FStar.Pervasives.Lemma (ensures v == v'))
-> LowParse.Low.Base.serializer32 (LowParse.Spec.Combinators.serialize_ret v v_unique) | Prims.Tot | [
"total"
] | [] | [
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"FStar.UInt32.__uint_to_t",
"LowParse.Low.Base.serializer32",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"LowParse.Spec.Combinators.serialize_ret"
] | [] | false | false | false | false | false | let serialize32_ret (#t: Type) (v: t) (v_unique: (v': t -> Lemma (v == v')))
: Tot (serializer32 (serialize_ret v v_unique)) =
| fun _ #_ #_ _ _ -> 0ul | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_snd' | val gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos')) | val gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos')) | let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 772,
"start_col": 0,
"start_line": 758
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _ | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
input: LowParse.Bytes.bytes
-> Prims.Ghost Prims.nat | Prims.Ghost | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"Prims.nat",
"Prims.unit",
"LowParse.Spec.Combinators.nondep_then_eq",
"Prims.l_True",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Combinators.clens_snd"
] | [] | false | false | false | false | false | let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos')) =
| nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0
| Some (_, consumed) -> consumed | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_false | val jump_false:jumper parse_false | val jump_false:jumper parse_false | let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul () | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 39,
"end_line": 437,
"start_col": 0,
"start_line": 436
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | LowParse.Low.Base.jumper LowParse.Spec.Combinators.parse_false | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.jump_constant_size",
"LowParse.Spec.Combinators.parse_false_kind",
"Prims.squash",
"Prims.l_False",
"LowParse.Spec.Combinators.parse_false",
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | true | false | let jump_false:jumper parse_false =
| jump_constant_size parse_false 0ul () | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.serialize32_empty | val serialize32_empty:serializer32 #_ #_ #parse_empty serialize_empty | val serialize32_empty:serializer32 #_ #_ #parse_empty serialize_empty | let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ()) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 34,
"end_line": 466,
"start_col": 0,
"start_line": 465
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | LowParse.Low.Base.serializer32 LowParse.Spec.Combinators.serialize_empty | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Combinators.serialize32_ret",
"Prims.unit"
] | [] | false | false | false | true | false | let serialize32_empty:serializer32 #_ #_ #parse_empty serialize_empty =
| serialize32_ret () (fun _ -> ()) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_lift_parser | val jump_lift_parser (#k: parser_kind) (#t: Type) (p: (unit -> Tot (parser k t))) (v: jumper (p ()))
: Tot (jumper (lift_parser p)) | val jump_lift_parser (#k: parser_kind) (#t: Type) (p: (unit -> Tot (parser k t))) (v: jumper (p ()))
: Tot (jumper (lift_parser p)) | let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 13,
"end_line": 509,
"start_col": 0,
"start_line": 500
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | p: (_: Prims.unit -> LowParse.Spec.Base.parser k t) -> v: LowParse.Low.Base.jumper (p ())
-> LowParse.Low.Base.jumper (LowParse.Spec.Combinators.lift_parser p) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.unit",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Combinators.valid_lift_parser",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.lift_parser"
] | [] | false | false | false | false | false | let jump_lift_parser (#k: parser_kind) (#t: Type) (p: (unit -> Tot (parser k t))) (v: jumper (p ()))
: Tot (jumper (lift_parser p)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_lift_parser | val validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: (unit -> Tot (parser k t)))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p)) | val validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: (unit -> Tot (parser k t)))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p)) | let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 13,
"end_line": 497,
"start_col": 0,
"start_line": 488
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | p: (_: Prims.unit -> LowParse.Spec.Base.parser k t) -> v: LowParse.Low.Base.validator (p ())
-> LowParse.Low.Base.validator (LowParse.Spec.Combinators.lift_parser p) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.unit",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.Combinators.valid_lift_parser",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.lift_parser"
] | [] | false | false | false | false | false | let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: (unit -> Tot (parser k t)))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_fst' | val gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos')) | val gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos')) | let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 699,
"start_col": 0,
"start_line": 686
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k1 t1 ->
sq: Prims.squash Prims.unit ->
p2: LowParse.Spec.Base.parser k2 t2 ->
input: LowParse.Bytes.bytes
-> Prims.Ghost Prims.nat | Prims.Ghost | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.squash",
"Prims.unit",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.nondep_then_eq",
"Prims.nat",
"Prims.l_True",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Combinators.clens_fst"
] | [] | false | false | false | false | false | let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos')) =
| nondep_then_eq p1 p2 input;
0 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.serialize32_false | val serialize32_false:serializer32 #_ #_ #parse_false serialize_false | val serialize32_false:serializer32 #_ #_ #parse_false serialize_false | let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 24,
"end_line": 470,
"start_col": 0,
"start_line": 469
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ()) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | LowParse.Low.Base.serializer32 LowParse.Spec.Combinators.serialize_false | Prims.Tot | [
"total"
] | [] | [
"Prims.squash",
"Prims.l_False",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"FStar.UInt32.__uint_to_t"
] | [] | false | false | false | true | false | let serialize32_false:serializer32 #_ #_ #parse_false serialize_false =
| fun _ #_ #_ _ _ -> 0ul | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_fst_eq | val gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma (gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input) | val gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma (gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input) | let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 64,
"end_line": 725,
"start_col": 0,
"start_line": 714
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k1 t1 ->
sq: Prims.squash Prims.unit ->
p2: LowParse.Spec.Base.parser k2 t2 ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Low.Combinators.gaccessor_fst p1 sq p2 input ==
LowParse.Low.Combinators.gaccessor_fst' p1 sq p2 input) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.squash",
"Prims.unit",
"LowParse.Bytes.bytes",
"FStar.Pervasives.reveal_opaque",
"Prims.nat",
"LowParse.Low.Combinators.gaccessor_fst",
"Prims.l_True",
"Prims.eq2",
"LowParse.Low.Combinators.gaccessor_fst'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma (gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input) =
| reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.valid_nondep_then | val valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (live_slice h s))
(ensures
((valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))) ==>
(valid p1 h s pos /\
(let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2)
h
s
pos
(contents p1 h s pos, contents p2 h s pos1)
(get_valid_pos p2 h s pos1))))) | val valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (live_slice h s))
(ensures
((valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))) ==>
(valid p1 h s pos /\
(let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2)
h
s
pos
(contents p1 h s pos, contents p2 h s pos1)
(get_valid_pos p2 h s pos1))))) | let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 45,
"start_col": 0,
"start_line": 13
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16" | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
h: FStar.Monotonic.HyperStack.mem ->
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Slice.live_slice h s)
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.Combinators.nondep_then p1 p2) h s pos \/
LowParse.Low.Base.Spec.valid p1 h s pos /\
LowParse.Low.Base.Spec.valid p2 h s (LowParse.Low.Base.Spec.get_valid_pos p1 h s pos) ==>
LowParse.Low.Base.Spec.valid p1 h s pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos p1 h s pos in
LowParse.Low.Base.Spec.valid p2 h s (LowParse.Low.Base.Spec.get_valid_pos p1 h s pos) /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Combinators.nondep_then p1 p2)
h
s
pos
(LowParse.Low.Base.Spec.contents p1 h s pos,
LowParse.Low.Base.Spec.contents p2 h s pos1)
(LowParse.Low.Base.Spec.get_valid_pos p2 h s pos1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.Base.Spec.valid_dec",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.bool",
"Prims.unit",
"LowParse.Spec.Combinators.nondep_then_eq",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Slice.live_slice",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_content_pos",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (live_slice h s))
(ensures
((valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))) ==>
(valid p1 h s pos /\
(let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2)
h
s
pos
(contents p1 h s pos, contents p2 h s pos1)
(get_valid_pos p2 h s pos1))))) =
| valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then
(nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_synth_inv' | val gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos')) | val gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos')) | let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 614,
"start_col": 0,
"start_line": 601
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f: (_: t1 -> Prims.GTot t2) ->
g: (_: t2 -> Prims.GTot t1) ->
u525:
u529:
Prims.unit
{LowParse.Spec.Combinators.synth_inverse f g /\ LowParse.Spec.Combinators.synth_injective f} ->
input: LowParse.Bytes.bytes
-> Prims.Ghost Prims.nat | Prims.Ghost | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"Prims.nat",
"Prims.l_True",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Low.Combinators.clens_synth_inv"
] | [] | false | false | false | false | false | let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos')) =
| parse_synth_eq p1 f input;
0 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.valid_lift_parser | val valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: (unit -> Tot (parser k t)))
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p)
h
input
pos
(contents (p ()) h input pos)
(get_valid_pos (p ()) h input pos)) | val valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: (unit -> Tot (parser k t)))
(h: HS.mem)
(#rrel #rel: _)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p)
h
input
pos
(contents (p ()) h input pos)
(get_valid_pos (p ()) h input pos)) | let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 41,
"end_line": 485,
"start_col": 0,
"start_line": 472
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p: (_: Prims.unit -> LowParse.Spec.Base.parser k t) ->
h: FStar.Monotonic.HyperStack.mem ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.Combinators.lift_parser p) h input pos \/
LowParse.Low.Base.Spec.valid (p ()) h input pos ==>
LowParse.Low.Base.Spec.valid (p ()) h input pos /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Combinators.lift_parser p)
h
input
pos
(LowParse.Low.Base.Spec.contents (p ()) h input pos)
(LowParse.Low.Base.Spec.get_valid_pos (p ()) h input pos)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"Prims.unit",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Combinators.lift_parser",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: (unit -> Tot (parser k t)))
(h: HS.mem)
#rrel
#rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p)
h
input
pos
(contents (p ()) h input pos)
(get_valid_pos (p ()) h input pos)) =
| valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_snd | val gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _)) | val gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _)) | let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 22,
"end_line": 818,
"start_col": 0,
"start_line": 807
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | p1: LowParse.Spec.Base.parser k1 t1 -> p2: LowParse.Spec.Base.parser k2 t2
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.Combinators.nondep_then p1 p2)
p2
(LowParse.Low.Combinators.clens_snd t1 t2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Combinators.gaccessor_snd'",
"Prims.unit",
"LowParse.Low.Base.Spec.gaccessor_prop_equiv",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Combinators.clens_snd",
"FStar.Classical.forall_intro_2",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"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.Base.no_lookahead_on_precond",
"Prims.nat",
"FStar.Classical.move_requires",
"LowParse.Low.Combinators.gaccessor_snd_no_lookahead",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Spec.Base.injective_precond",
"LowParse.Low.Combinators.gaccessor_snd_injective",
"LowParse.Low.Base.Spec.gaccessor"
] | [] | false | false | false | false | false | let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _)) =
| Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_then_fst | val gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` (clens_fst _ _))) | val gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` (clens_fst _ _))) | let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _ | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 44,
"end_line": 756,
"start_col": 0,
"start_line": 743
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | g: LowParse.Low.Base.Spec.gaccessor p0 (LowParse.Spec.Combinators.nondep_then p1 p2) cl
-> LowParse.Low.Base.Spec.gaccessor p0
p1
(LowParse.Low.Base.Spec.clens_compose cl (LowParse.Low.Combinators.clens_fst t1 t2)) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"FStar.Pervasives.Native.tuple2",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Base.Spec.gaccessor_compose",
"LowParse.Low.Combinators.clens_fst",
"LowParse.Low.Combinators.gaccessor_fst",
"LowParse.Low.Base.Spec.clens_compose"
] | [] | false | false | false | false | false | let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` (clens_fst _ _))) =
| g `gaccessor_compose` (gaccessor_fst _ () _) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.serialize32_nondep_then_aux | val serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel #rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\ U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h))
(ensures
(fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\
(B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\ B.live h b /\
(Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len))
`Seq.equal`
((serialize s1 x1) `Seq.append` (serialize s2 x2))))) | val serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel #rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\ U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h))
(ensures
(fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\
(B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\ B.live h b /\
(Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len))
`Seq.equal`
((serialize s1 x1) `Seq.append` (serialize s2 x2))))) | let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 21,
"end_line": 168,
"start_col": 0,
"start_line": 128
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
s1': LowParse.Low.Base.serializer32 s1 ->
s2': LowParse.Low.Base.serializer32 s2 ->
x1: t1 ->
x2: t2 ->
b: LowStar.Monotonic.Buffer.mbuffer LowParse.Bytes.byte rrel rel ->
pos: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack FStar.UInt32.t | FStar.HyperStack.ST.Stack | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.serializer32",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"FStar.UInt32.add",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.frame_serializer32",
"FStar.Ghost.hide",
"FStar.Ghost.erased",
"FStar.UInt32.uint_to_t",
"Prims.op_Addition",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowStar.Monotonic.Buffer.length",
"LowParse.Low.Base.writable",
"FStar.Seq.Base.seq",
"LowStar.Monotonic.Buffer.as_seq",
"Prims.int",
"Prims.nat",
"Prims.eq2",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_buffer_from_to",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.append"
] | [] | false | true | false | false | false | let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1': serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2': serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel #rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires
(fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\ U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h))
(ensures
(fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\
(B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\ B.live h b /\
(Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len))
`Seq.equal`
((serialize s1 x1) `Seq.append` (serialize s2 x2))))) =
| let gpos' =
Ghost.hide (pos
`U32.add`
(U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))))
in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.valid_dtuple2 | val valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (live_slice h s))
(ensures
((valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))) ==>
(valid p1 h s pos /\
(let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2)
h
s
pos
(| x, contents (p2 x) h s pos1 |)
(get_valid_pos (p2 x) h s pos1))))) | val valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (live_slice h s))
(ensures
((valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))) ==>
(valid p1 h s pos /\
(let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2)
h
s
pos
(| x, contents (p2 x) h s pos1 |)
(get_valid_pos (p2 x) h s pos1))))) | let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 303,
"start_col": 0,
"start_line": 269
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
h: FStar.Monotonic.HyperStack.mem ->
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: (x: t1 -> LowParse.Spec.Base.parser k2 (t2 x)) ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Slice.live_slice h s)
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.Combinators.parse_dtuple2 p1 p2) h s pos \/
LowParse.Low.Base.Spec.valid p1 h s pos /\
LowParse.Low.Base.Spec.valid (p2 (LowParse.Low.Base.Spec.contents p1 h s pos))
h
s
(LowParse.Low.Base.Spec.get_valid_pos p1 h s pos) ==>
LowParse.Low.Base.Spec.valid p1 h s pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos p1 h s pos in
let x = LowParse.Low.Base.Spec.contents p1 h s pos in
LowParse.Low.Base.Spec.valid (p2 x) h s (LowParse.Low.Base.Spec.get_valid_pos p1 h s pos) /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Combinators.parse_dtuple2 p1 p2)
h
s
pos
(| x, LowParse.Low.Base.Spec.contents (p2 x) h s pos1 |)
(LowParse.Low.Base.Spec.get_valid_pos (p2 x) h s pos1))) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.Base.Spec.valid_dec",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.bool",
"Prims.unit",
"LowParse.Spec.Combinators.parse_dtuple2_eq",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.Combinators.and_then_kind",
"Prims.dtuple2",
"LowParse.Spec.Combinators.parse_dtuple2",
"LowParse.Slice.live_slice",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_content_pos",
"Prims.Mkdtuple2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: (t1 -> Type))
(p2: (x: t1 -> parser k2 (t2 x)))
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (live_slice h s))
(ensures
((valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))) ==>
(valid p1 h s pos /\
(let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2)
h
s
pos
(| x, contents (p2 x) h s pos1 |)
(get_valid_pos (p2 x) h s pos1))))) =
| valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then
(parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.accessor_then_fst | val accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g)) | val accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g)) | let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) () | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 47,
"end_line": 922,
"start_col": 0,
"start_line": 908
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | a: LowParse.Low.Base.accessor g
-> LowParse.Low.Base.accessor (LowParse.Low.Combinators.gaccessor_then_fst g) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"FStar.Pervasives.Native.tuple2",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Base.accessor",
"LowParse.Low.Base.accessor_compose",
"LowParse.Low.Combinators.clens_fst",
"LowParse.Low.Combinators.gaccessor_fst",
"LowParse.Low.Combinators.accessor_fst",
"LowParse.Low.Base.Spec.clens_compose",
"LowParse.Low.Combinators.gaccessor_then_fst"
] | [] | false | false | false | false | false | let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g)) =
| accessor_compose a (accessor_fst p1 () p2) () | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.accessor_synth_inv | val accessor_synth_inv
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
: Tot (accessor (gaccessor_synth_inv p1 f g u)) | val accessor_synth_inv
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
: Tot (accessor (gaccessor_synth_inv p1 f g u)) | let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 654,
"start_col": 0,
"start_line": 639
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f: (_: t1 -> Prims.GTot t2) ->
g: (_: t2 -> Prims.GTot t1) ->
u554:
u557:
Prims.unit
{LowParse.Spec.Combinators.synth_inverse f g /\ LowParse.Spec.Combinators.synth_injective f}
-> LowParse.Low.Base.accessor (LowParse.Low.Combinators.gaccessor_synth_inv p1 f g u554) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.slice_access_eq",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Low.Combinators.clens_synth_inv",
"LowParse.Low.Combinators.gaccessor_synth_inv",
"FStar.Classical.forall_intro",
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.nat",
"LowParse.Low.Combinators.gaccessor_synth_inv'",
"LowParse.Low.Combinators.gaccessor_synth_inv_eq",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.accessor"
] | [] | false | false | false | false | false | let accessor_synth_inv
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
: Tot (accessor (gaccessor_synth_inv p1 f g u)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_synth' | val gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos')) | val gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos')) | let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 542,
"start_col": 0,
"start_line": 528
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f: (_: t1 -> Prims.GTot t2) ->
g: (_: t2 -> Prims.GTot t1) ->
u471:
u475:
Prims.unit
{LowParse.Spec.Combinators.synth_inverse f g /\ LowParse.Spec.Combinators.synth_injective f} ->
input: LowParse.Bytes.bytes
-> Prims.Ghost Prims.nat | Prims.Ghost | [] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Bytes.bytes",
"LowParse.Spec.Combinators.parse_synth_eq",
"LowParse.Spec.Combinators.synth_injective_synth_inverse_synth_inverse_recip",
"Prims.nat",
"Prims.l_True",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Low.Combinators.clens_synth"
] | [] | false | false | false | false | false | let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos')) =
| synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.accessor_snd | val accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2)) | val accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2)) | let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 943,
"start_col": 0,
"start_line": 925
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | j1: LowParse.Low.Base.jumper p1 -> p2: LowParse.Spec.Base.parser k2 t2
-> LowParse.Low.Base.accessor (LowParse.Low.Combinators.gaccessor_snd p1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.Base.Spec.slice_access_eq",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Combinators.clens_snd",
"LowParse.Low.Combinators.gaccessor_snd",
"LowParse.Low.Combinators.valid_nondep_then",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"FStar.Pervasives.reveal_opaque",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Low.Base.accessor"
] | [] | false | false | false | false | false | let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2)) =
| reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@@ inline_let ]let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_snd_injective | val gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl')) | val gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl')) | let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl' | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 787,
"start_col": 0,
"start_line": 774
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Combinators.nondep_then p1 p2)
p2
(LowParse.Low.Combinators.clens_snd t1 t2)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Combinators.nondep_then p1 p2)
p2
(LowParse.Low.Combinators.clens_snd t1 t2)
sl /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.Combinators.nondep_then p1 p2) sl sl')
(ensures
LowParse.Low.Combinators.gaccessor_snd' p1 p2 sl ==
LowParse.Low.Combinators.gaccessor_snd' p1 p2 sl') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Combinators.nondep_then_eq",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Combinators.clens_snd",
"LowParse.Spec.Base.injective_precond",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"LowParse.Low.Combinators.gaccessor_snd'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl')) =
| nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl' | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.clens_tagged_union_tag | val clens_tagged_union_tag (#tag_t #data_t: Type) (tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t) | val clens_tagged_union_tag (#tag_t #data_t: Type) (tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t) | let clens_tagged_union_tag
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t)
= {
clens_cond = (fun _ -> True);
clens_get = tag_of_data;
} | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1406,
"start_col": 0,
"start_line": 1398
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos
inline_for_extraction
let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos
inline_for_extraction
let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
inline_for_extraction
let jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | tag_of_data: (_: data_t -> Prims.GTot tag_t) -> LowParse.Low.Base.Spec.clens data_t tag_t | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.Mkclens",
"Prims.l_True",
"LowParse.Low.Base.Spec.clens"
] | [] | false | false | false | false | false | let clens_tagged_union_tag (#tag_t #data_t: Type) (tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t) =
| { clens_cond = (fun _ -> True); clens_get = tag_of_data } | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.valid_filter | val valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==>
(valid p h input pos /\ f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f)
h
input
pos
(contents p h input pos)
(get_valid_pos p h input pos))) | val valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==>
(valid p h input pos /\ f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f)
h
input
pos
(contents p h input pos)
(get_valid_pos p h input pos))) | let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 60,
"end_line": 1003,
"start_col": 0,
"start_line": 984
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
h: FStar.Monotonic.HyperStack.mem ->
p: LowParse.Spec.Base.parser k t ->
f: (_: t -> Prims.GTot Prims.bool) ->
input: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(ensures
LowParse.Low.Base.Spec.valid (LowParse.Spec.Combinators.parse_filter p f) h input pos \/
LowParse.Low.Base.Spec.valid p h input pos /\
f (LowParse.Low.Base.Spec.contents p h input pos) ==>
LowParse.Low.Base.Spec.valid p h input pos /\
f (LowParse.Low.Base.Spec.contents p h input pos) == true /\
LowParse.Low.Base.Spec.valid_content_pos (LowParse.Spec.Combinators.parse_filter p f)
h
input
pos
(LowParse.Low.Base.Spec.contents p h input pos)
(LowParse.Low.Base.Spec.get_valid_pos p h input pos)) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.bool",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Spec.Combinators.parse_filter_eq",
"LowParse.Slice.bytes_of_slice_from",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter",
"Prims.l_True",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid",
"Prims.l_and",
"Prims.b2t",
"LowParse.Low.Base.Spec.contents",
"Prims.eq2",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | false | false | true | false | false | let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==>
(valid p h input pos /\ f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f)
h
input
pos
(contents p h input pos)
(get_valid_pos p h input pos))) =
| valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len then parse_filter_eq p f (bytes_of_slice_from h input pos) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_snd_eq | val gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma (gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input) | val gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma (gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input) | let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input ) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 62,
"end_line": 830,
"start_col": 0,
"start_line": 820
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
LowParse.Low.Combinators.gaccessor_snd p1 p2 input ==
LowParse.Low.Combinators.gaccessor_snd' p1 p2 input) | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"FStar.Pervasives.reveal_opaque",
"Prims.nat",
"LowParse.Low.Combinators.gaccessor_snd",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Low.Combinators.gaccessor_snd'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma (gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input) =
| reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_compose_context | val jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(v: (k: kt1 -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k))) | val jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(v: (k: kt1 -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k))) | let jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 47,
"end_line": 1396,
"start_col": 0,
"start_line": 1387
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos
inline_for_extraction
let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos
inline_for_extraction
let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
f: (_: kt2 -> kt1) ->
t: (_: kt1 -> Type) ->
p: (k: kt1 -> LowParse.Spec.Base.parser pk (t k)) ->
v: (k: kt1 -> LowParse.Low.Base.jumper (p k)) ->
k: kt2
-> LowParse.Low.Base.jumper (p (f k)) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t"
] | [] | false | false | false | false | false | let jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(v: (k: kt1 -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k))) =
| fun #rrel #rel input pos -> v (f k) input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.accessor_synth | val accessor_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
: Tot (accessor (gaccessor_synth p1 f g u)) | val accessor_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
: Tot (accessor (gaccessor_synth p1 f g u)) | let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 582,
"start_col": 0,
"start_line": 567
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f: (_: t1 -> Prims.GTot t2) ->
g: (_: t2 -> Prims.GTot t1) ->
u500:
u503:
Prims.unit
{LowParse.Spec.Combinators.synth_inverse f g /\ LowParse.Spec.Combinators.synth_injective f}
-> LowParse.Low.Base.accessor (LowParse.Low.Combinators.gaccessor_synth p1 f g u500) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.unit",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.slice_access_eq",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Low.Combinators.clens_synth",
"LowParse.Low.Combinators.gaccessor_synth",
"FStar.Classical.forall_intro",
"LowParse.Bytes.bytes",
"Prims.eq2",
"Prims.nat",
"LowParse.Low.Combinators.gaccessor_synth'",
"LowParse.Low.Combinators.gaccessor_synth_eq",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.accessor"
] | [] | false | false | false | false | false | let accessor_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f: (t1 -> GTot t2))
(g: (t2 -> GTot t1))
(u: unit{synth_inverse f g /\ synth_injective f})
: Tot (accessor (gaccessor_synth p1 f g u)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_compose_context | val validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(v: (k: kt1 -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k))) | val validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(v: (k: kt1 -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k))) | let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 47,
"end_line": 1384,
"start_col": 0,
"start_line": 1375
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos
inline_for_extraction
let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
f: (_: kt2 -> kt1) ->
t: (_: kt1 -> Type) ->
p: (k: kt1 -> LowParse.Spec.Base.parser pk (t k)) ->
v: (k: kt1 -> LowParse.Low.Base.validator (p k)) ->
k: kt2
-> LowParse.Low.Base.validator (p (f k)) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t"
] | [] | false | false | false | false | false | let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: (k: kt1 -> Tot (parser pk (t k))))
(v: (k: kt1 -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k))) =
| fun #rrel #rel input pos -> v (f k) input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_snd_no_lookahead | val gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl': bytes)
: Lemma
(requires
((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl')) | val gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl': bytes)
: Lemma
(requires
((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl')) | let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl' | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 31,
"end_line": 804,
"start_col": 0,
"start_line": 789
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind (LowParse.Spec.Combinators.and_then_kind k1 k2) ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Combinators.nondep_then p1 p2)
p2
(LowParse.Low.Combinators.clens_snd t1 t2)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Combinators.nondep_then p1 p2)
p2
(LowParse.Low.Combinators.clens_snd t1 t2)
sl /\
LowParse.Spec.Base.no_lookahead_on_precond (LowParse.Spec.Combinators.nondep_then p1 p2)
sl
sl')
(ensures
LowParse.Low.Combinators.gaccessor_snd' p1 p2 sl ==
LowParse.Low.Combinators.gaccessor_snd' p1 p2 sl') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_strong_prefix",
"Prims.unit",
"LowParse.Spec.Base.parse_injective",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Spec.Combinators.nondep_then_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",
"LowParse.Low.Combinators.clens_snd",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.squash",
"Prims.nat",
"LowParse.Low.Combinators.gaccessor_snd'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl': bytes)
: Lemma
(requires
((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\
no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl')) =
| nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl';
parse_strong_prefix p1 sl sl' | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.serialize32_filter | val serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f)) | val serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f)) | let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 17,
"end_line": 1151,
"start_col": 0,
"start_line": 1142
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | s32: LowParse.Low.Base.serializer32 s -> f: (_: t -> Prims.GTot Prims.bool)
-> LowParse.Low.Base.serializer32 (LowParse.Spec.Combinators.serialize_filter s f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.serializer32",
"Prims.bool",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Combinators.serialize_filter"
] | [] | false | false | false | false | false | let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f)) =
| fun x #rrel #rel input pos -> s32 x input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_filter | val validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
: Tot (validator (parse_filter p f)) | val validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
: Tot (validator (parse_filter p f)) | let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 12,
"end_line": 1025,
"start_col": 0,
"start_line": 1006
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
v32: LowParse.Low.Base.validator p ->
p32: LowParse.Low.Base.leaf_reader p ->
f: (_: t -> Prims.GTot Prims.bool) ->
f': (x: t -> y: Prims.bool{y == f x})
-> LowParse.Low.Base.validator (LowParse.Spec.Combinators.parse_filter p f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"LowParse.Low.Base.leaf_reader",
"Prims.bool",
"Prims.eq2",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.is_error",
"Prims.op_Negation",
"LowParse.Low.ErrorCode.validator_error_generic",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"Prims.unit",
"LowParse.Low.Combinators.valid_filter",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter"
] | [] | false | false | false | false | false | let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
: Tot (validator (parse_filter p f)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va) then validator_error_generic else res | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_filter | val read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f)) | val read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f)) | let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 48,
"end_line": 1105,
"start_col": 0,
"start_line": 1095
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | p32: LowParse.Low.Base.leaf_reader p -> f: (_: t -> Prims.GTot Prims.bool)
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Combinators.parse_filter p f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.leaf_reader",
"Prims.bool",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.unit",
"LowParse.Low.Combinators.valid_filter",
"LowParse.Spec.Combinators.parse_filter_refine",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter"
] | [] | false | false | false | false | false | let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t{f res == true})) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.accessor_fst | val accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2)) | val accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2)) | let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 887,
"start_col": 0,
"start_line": 874
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k1 t1 ->
sq: Prims.squash Prims.unit ->
p2: LowParse.Spec.Base.parser k2 t2
-> LowParse.Low.Base.accessor (LowParse.Low.Combinators.gaccessor_fst p1 sq p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.squash",
"Prims.unit",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.slice_access_eq",
"LowParse.Spec.Combinators.and_then_kind",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Combinators.nondep_then",
"LowParse.Low.Combinators.clens_fst",
"LowParse.Low.Combinators.gaccessor_fst",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"FStar.Pervasives.reveal_opaque",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Low.Base.accessor"
] | [] | false | false | false | false | false | let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2)) =
| reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.make_total_constant_size_reader | val make_total_constant_size_reader
(sz: nat)
(sz': U32.t{U32.v sz' == sz})
(#t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (t)))
(u: unit{make_total_constant_size_parser_precond sz t f})
(f':
(#rrel: _ -> #rel: _ -> s: B.mbuffer byte rrel rel -> pos: U32.t
-> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures
(fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f)) | val make_total_constant_size_reader
(sz: nat)
(sz': U32.t{U32.v sz' == sz})
(#t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (t)))
(u: unit{make_total_constant_size_parser_precond sz t f})
(f':
(#rrel: _ -> #rel: _ -> s: B.mbuffer byte rrel rel -> pos: U32.t
-> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures
(fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f)) | let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 16,
"end_line": 982,
"start_col": 0,
"start_line": 964
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
sz: Prims.nat ->
sz': FStar.UInt32.t{FStar.UInt32.v sz' == sz} ->
f: (s: LowParse.Bytes.bytes{FStar.Seq.Base.length s == sz} -> Prims.GTot t) ->
u893: u898: Prims.unit{LowParse.Spec.Combinators.make_total_constant_size_parser_precond sz t f} ->
f':
(s: LowStar.Monotonic.Buffer.mbuffer LowParse.Bytes.byte rrel rel -> pos: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack t)
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Combinators.make_total_constant_size_parser sz t f
) | Prims.Tot | [
"total"
] | [] | [
"Prims.nat",
"FStar.UInt32.t",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.b2t",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt32.v",
"LowParse.Bytes.bytes",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.unit",
"LowParse.Spec.Combinators.make_total_constant_size_parser_precond",
"LowStar.Monotonic.Buffer.srel",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.live",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"LowStar.Monotonic.Buffer.length",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_none",
"FStar.Seq.Base.slice",
"LowStar.Monotonic.Buffer.as_seq",
"LowParse.Slice.srel",
"LowParse.Slice.slice",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Base.total_constant_size_parser_kind",
"LowParse.Spec.Combinators.make_total_constant_size_parser",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.leaf_reader"
] | [] | false | false | false | false | false | let make_total_constant_size_reader
(sz: nat)
(sz': U32.t{U32.v sz' == sz})
(#t: Type)
(f: (s: bytes{Seq.length s == sz} -> GTot (t)))
(u: unit{make_total_constant_size_parser_precond sz t f})
(f':
(#rrel: _ -> #rel: _ -> s: B.mbuffer byte rrel rel -> pos: U32.t
-> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures
(fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f)) =
| fun #rrel #rel sl pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.write_filter_weak | val write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f)) | val write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f)) | let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 1139,
"start_col": 0,
"start_line": 1125
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | s32: LowParse.Low.Base.leaf_writer_weak s -> f: (_: t -> Prims.GTot Prims.bool)
-> LowParse.Low.Base.leaf_writer_weak (LowParse.Spec.Combinators.serialize_filter s f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_weak",
"Prims.bool",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Combinators.valid_filter",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.Spec.serialized_length_eq",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Combinators.serialize_filter"
] | [] | false | false | false | false | false | let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f)) =
| fun x #rrel #rel input pos ->
[@@ inline_let ]let _ = serialized_length_eq s x in
[@@ inline_let ]let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@@ inline_let ]let _ = valid_filter h p f input pos in
res | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.write_filter | val write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f)) | val write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f)) | let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 1122,
"start_col": 0,
"start_line": 1108
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion? | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | s32: LowParse.Low.Base.leaf_writer_strong s -> f: (_: t -> Prims.GTot Prims.bool)
-> LowParse.Low.Base.leaf_writer_strong (LowParse.Spec.Combinators.serialize_filter s f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_strong",
"Prims.bool",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Combinators.valid_filter",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.Spec.serialized_length_eq",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.Combinators.serialize_filter"
] | [] | false | false | false | false | false | let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f)) =
| fun x #rrel #rel input pos ->
[@@ inline_let ]let _ = serialized_length_eq s x in
[@@ inline_let ]let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@@ inline_let ]let _ = valid_filter h p f input pos in
res | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_synth' | val read_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> Tot t2))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) | val read_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> Tot t2))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) | let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 40,
"end_line": 1184,
"start_col": 0,
"start_line": 1173
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding? | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> t2) ->
p1': LowParse.Low.Base.leaf_reader p1 ->
u1058: u1060: Prims.unit{LowParse.Spec.Combinators.synth_injective f2}
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Combinators.parse_synth p1 f2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.leaf_reader",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Low.Combinators.read_synth",
"Prims.eq2",
"LowParse.Spec.Combinators.parse_synth"
] | [] | false | false | false | false | false | let read_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> Tot t2))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) =
| read_synth p1 f2 (fun x -> f2 x) p1' u | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_filter_ret | val validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
: Tot (validator (parse_filter (parse_ret r) f)) | val validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
: Tot (validator (parse_filter (parse_ret r) f)) | let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 10,
"end_line": 1063,
"start_col": 0,
"start_line": 1051
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | r: t -> f: (_: t -> Prims.GTot Prims.bool) -> f': (x: t -> y: Prims.bool{y == f x})
-> LowParse.Low.Base.validator (LowParse.Spec.Combinators.parse_filter (LowParse.Spec.Combinators.parse_ret
r)
f) | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Prims.eq2",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"Prims.op_Negation",
"LowParse.Low.ErrorCode.validator_error_generic",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"LowParse.Low.Combinators.valid_filter",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.validator",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter"
] | [] | false | false | false | false | false | let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
: Tot (validator (parse_filter (parse_ret r) f)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@@ inline_let ]let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r) then validator_error_generic else pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_filter_with_error_code | val validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
(c: error_code)
: Tot (validator (parse_filter p f)) | val validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
(c: error_code)
: Tot (validator (parse_filter p f)) | let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 12,
"end_line": 1048,
"start_col": 0,
"start_line": 1028
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
v32: LowParse.Low.Base.validator p ->
p32: LowParse.Low.Base.leaf_reader p ->
f: (_: t -> Prims.GTot Prims.bool) ->
f': (x: t -> y: Prims.bool{y == f x}) ->
c: LowParse.Low.ErrorCode.error_code
-> LowParse.Low.Base.validator (LowParse.Spec.Combinators.parse_filter p f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"LowParse.Low.Base.leaf_reader",
"Prims.bool",
"Prims.eq2",
"LowParse.Low.ErrorCode.error_code",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"LowParse.Low.ErrorCode.is_error",
"LowParse.Low.ErrorCode.maybe_set_validator_error_pos_and_code",
"Prims.op_Negation",
"LowParse.Low.ErrorCode.set_validator_error_pos_and_code",
"LowParse.Low.ErrorCode.validator_error_generic",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"Prims.unit",
"LowParse.Low.Combinators.valid_filter",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter"
] | [] | false | false | false | false | false | let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
(c: error_code)
: Tot (validator (parse_filter p f)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va) then set_validator_error_pos_and_code validator_error_generic pos c else res | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_filter | val jump_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (j: jumper p) (f: (t -> GTot bool))
: Tot (jumper (parse_filter p f)) | val jump_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (j: jumper p) (f: (t -> GTot bool))
: Tot (jumper (parse_filter p f)) | let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 13,
"end_line": 1092,
"start_col": 0,
"start_line": 1082
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | j: LowParse.Low.Base.jumper p -> f: (_: t -> Prims.GTot Prims.bool)
-> LowParse.Low.Base.jumper (LowParse.Spec.Combinators.parse_filter p f) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"Prims.bool",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Combinators.valid_filter",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter"
] | [] | false | false | false | false | false | let jump_filter (#k: parser_kind) (#t: Type) (#p: parser k t) (j: jumper p) (f: (t -> GTot bool))
: Tot (jumper (parse_filter p f)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_filter h p f input pos in
j input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_filter_ret_with_error_code | val validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f)) | val validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f)) | let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 10,
"end_line": 1079,
"start_col": 0,
"start_line": 1066
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
r: t ->
f: (_: t -> Prims.GTot Prims.bool) ->
f': (x: t -> y: Prims.bool{y == f x}) ->
c: LowParse.Low.ErrorCode.error_code
-> LowParse.Low.Base.validator (LowParse.Spec.Combinators.parse_filter (LowParse.Spec.Combinators.parse_ret
r)
f) | Prims.Tot | [
"total"
] | [] | [
"Prims.bool",
"Prims.eq2",
"LowParse.Low.ErrorCode.error_code",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"Prims.op_Negation",
"LowParse.Low.ErrorCode.set_validator_error_pos_and_code",
"LowParse.Low.ErrorCode.validator_error_generic",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Combinators.parse_ret_kind",
"LowParse.Spec.Combinators.parse_ret",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"LowParse.Low.Combinators.valid_filter",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.validator",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter"
] | [] | false | false | false | false | false | let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f': (x: t -> Tot (y: bool{y == f x})))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@@ inline_let ]let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r) then set_validator_error_pos_and_code validator_error_generic pos c else pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_inline_synth | val read_inline_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(f2': (x: t1 -> Tot (y: t2{y == f2 x})))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) | val read_inline_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(f2': (x: t1 -> Tot (y: t2{y == f2 x})))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) | let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos) | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 22,
"end_line": 1203,
"start_col": 0,
"start_line": 1187
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
f2': (x: t1 -> y: t2{y == f2 x}) ->
p1': LowParse.Low.Base.leaf_reader p1 ->
u1075: u1079: Prims.unit{LowParse.Spec.Combinators.synth_injective f2}
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Combinators.parse_synth p1 f2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.eq2",
"LowParse.Low.Base.leaf_reader",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_True",
"Prims.l_and",
"LowParse.Low.Combinators.valid_synth",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.parse_synth"
] | [] | false | false | false | false | false | let read_inline_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(f2': (x: t1 -> Tot (y: t2{y == f2 x})))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_synth h p1 f2 input pos in
[@@ inline_let ]let f2'' (x: t1)
: HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) =
f2' x
in
f2'' (p1' input pos) | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_synth | val read_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(f2': (x: t1 -> Tot (y: t2{y == f2 x})))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) | val read_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(f2': (x: t1 -> Tot (y: t2{y == f2 x})))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) | let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 15,
"end_line": 1170,
"start_col": 0,
"start_line": 1154
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> Prims.GTot t2) ->
f2': (x: t1 -> y: t2{y == f2 x}) ->
p1': LowParse.Low.Base.leaf_reader p1 ->
u1045: u1049: Prims.unit{LowParse.Spec.Combinators.synth_injective f2}
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Combinators.parse_synth p1 f2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"Prims.eq2",
"LowParse.Low.Base.leaf_reader",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Combinators.valid_synth",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Spec.Combinators.parse_synth"
] | [] | false | false | false | false | false | let read_synth
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> GTot t2))
(f2': (x: t1 -> Tot (y: t2{y == f2 x})))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.read_inline_synth' | val read_inline_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> Tot t2))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) | val read_inline_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> Tot t2))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) | let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' () | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 48,
"end_line": 1217,
"start_col": 0,
"start_line": 1206
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
p1: LowParse.Spec.Base.parser k t1 ->
f2: (_: t1 -> t2) ->
p1': LowParse.Low.Base.leaf_reader p1 ->
u1088: u1090: Prims.unit{LowParse.Spec.Combinators.synth_injective f2}
-> LowParse.Low.Base.leaf_reader (LowParse.Spec.Combinators.parse_synth p1 f2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.leaf_reader",
"Prims.unit",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Low.Combinators.read_inline_synth",
"Prims.eq2",
"LowParse.Spec.Combinators.parse_synth"
] | [] | false | false | false | false | false | let read_inline_synth'
(#k: parser_kind)
(#t1 #t2: Type)
(p1: parser k t1)
(f2: (t1 -> Tot t2))
(p1': leaf_reader p1)
(u: unit{synth_injective f2})
: Tot (leaf_reader (parse_synth p1 f2)) =
| read_inline_synth p1 f2 (fun x -> f2 x) p1' () | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.write_synth | val write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1': leaf_writer_strong s1)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(g1': (x2: t2 -> Tot (x1: t1{x1 == g1 x2})))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ())) | val write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1': leaf_writer_strong s1)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(g1': (x2: t2 -> Tot (x1: t1{x1 == g1 x2})))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ())) | let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos' | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 6,
"end_line": 1239,
"start_col": 0,
"start_line": 1220
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' () | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
s1': LowParse.Low.Base.leaf_writer_strong s1 ->
f2: (_: t1 -> Prims.GTot t2) ->
g1: (_: t2 -> Prims.GTot t1) ->
g1': (x2: t2 -> x1: t1{x1 == g1 x2}) ->
u1111:
Prims.squash (LowParse.Spec.Combinators.synth_injective f2 /\
LowParse.Spec.Combinators.synth_inverse f2 g1)
-> LowParse.Low.Base.leaf_writer_strong (LowParse.Spec.Combinators.serialize_synth p1 f2 s1 g1 ()) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_strong",
"Prims.eq2",
"Prims.squash",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Combinators.valid_synth",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.Spec.serialized_length_eq",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Combinators.serialize_synth_eq"
] | [] | false | false | false | false | false | let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1': leaf_writer_strong s1)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(g1': (x2: t2 -> Tot (x1: t1{x1 == g1 x2})))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ())) =
| fun x #rrel #rel input pos ->
[@@ inline_let ]let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@@ inline_let ]let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@@ inline_let ]let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@@ inline_let ]let _ = valid_synth h p1 f2 input pos in
pos' | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.write_synth_weak | val write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1': leaf_writer_weak s1)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(g1': (x2: t2 -> Tot (x1: t1{x1 == g1 x2})))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ())) | val write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1': leaf_writer_weak s1)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(g1': (x2: t2 -> Tot (x1: t1{x1 == g1 x2})))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ())) | let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos' | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 6,
"end_line": 1261,
"start_col": 0,
"start_line": 1242
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
s1': LowParse.Low.Base.leaf_writer_weak s1 ->
f2: (_: t1 -> Prims.GTot t2) ->
g1: (_: t2 -> Prims.GTot t1) ->
g1': (x2: t2 -> x1: t1{x1 == g1 x2}) ->
u1131:
Prims.squash (LowParse.Spec.Combinators.synth_injective f2 /\
LowParse.Spec.Combinators.synth_inverse f2 g1)
-> LowParse.Low.Base.leaf_writer_weak (LowParse.Spec.Combinators.serialize_synth p1 f2 s1 g1 ()) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.leaf_writer_weak",
"Prims.eq2",
"Prims.squash",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Spec.Combinators.synth_inverse",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Combinators.valid_synth",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"LowParse.Low.Base.Spec.serialized_length_eq",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.serialize_synth",
"LowParse.Spec.Combinators.serialize_synth_eq"
] | [] | false | false | false | false | false | let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1': leaf_writer_weak s1)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(g1': (x2: t2 -> Tot (x1: t1{x1 == g1 x2})))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ())) =
| fun x #rrel #rel input pos ->
[@@ inline_let ]let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@@ inline_let ]let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@@ inline_let ]let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@@ inline_let ]let _ = valid_synth h p1 f2 input pos in
pos' | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.serialize32_synth | val serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1': serializer32 s1)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(g1': (x2: t2 -> Tot (x1: t1{x1 == g1 x2})))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ())) | val serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1': serializer32 s1)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(g1': (x2: t2 -> Tot (x1: t1{x1 == g1 x2})))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ())) | let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 23,
"end_line": 1280,
"start_col": 0,
"start_line": 1264
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
s1': LowParse.Low.Base.serializer32 s1 ->
f2: (_: t1 -> Prims.GTot t2) ->
g1: (_: t2 -> Prims.GTot t1) ->
g1': (x2: t2 -> x1: t1{x1 == g1 x2}) ->
u1151:
Prims.squash (LowParse.Spec.Combinators.synth_injective f2 /\
LowParse.Spec.Combinators.synth_inverse f2 g1)
-> LowParse.Low.Base.serializer32 (LowParse.Spec.Combinators.serialize_synth p1 f2 s1 g1 ()) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Low.Base.serializer32",
"Prims.eq2",
"Prims.squash",
"Prims.l_and",
"LowParse.Spec.Combinators.synth_injective",
"LowParse.Spec.Combinators.synth_inverse",
"LowStar.Monotonic.Buffer.srel",
"LowParse.Bytes.byte",
"LowStar.Monotonic.Buffer.mbuffer",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Spec.Combinators.serialize_synth_eq",
"LowParse.Spec.Combinators.parse_synth",
"LowParse.Spec.Combinators.serialize_synth"
] | [] | false | false | false | false | false | let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1': serializer32 s1)
(#t2: Type)
(f2: (t1 -> GTot t2))
(g1: (t2 -> GTot t1))
(g1': (x2: t2 -> Tot (x1: t1{x1 == g1 x2})))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ())) =
| fun x #rrel #rel input pos ->
[@@ inline_let ]let _ = serialize_synth_eq p1 f2 s1 g1 () x in
s1' (g1' x) input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.jump_weaken | val jump_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2)) | val jump_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2)) | let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 1355,
"start_col": 0,
"start_line": 1341
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
k1: LowParse.Spec.Base.parser_kind ->
v2: LowParse.Low.Base.jumper p2 ->
sq: Prims.squash (LowParse.Spec.Base.is_weaker_than k1 k2)
-> LowParse.Low.Base.jumper (LowParse.Spec.Base.weaken k1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"Prims.squash",
"LowParse.Spec.Base.is_weaker_than",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Base.weaken",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | false | false | false | false | let jump_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_facts (weaken k1 p2) h input pos in
[@@ inline_let ]let _ = valid_facts p2 h input pos in
v2 input pos | false |
Hacl.Impl.Ed25519.Pow2_252m2.fst | Hacl.Impl.Ed25519.Pow2_252m2.pow2_252m2 | val pow2_252m2:
out:felem
-> z:felem ->
Stack unit
(requires fun h -> live h out /\ live h z /\ disjoint out z /\ F51.mul_inv_t h z)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.mul_inv_t h1 out /\
F51.fevalh h1 out == F51.fevalh h0 z `SC.fpow` ((SC.prime + 3) / 8)
) | val pow2_252m2:
out:felem
-> z:felem ->
Stack unit
(requires fun h -> live h out /\ live h z /\ disjoint out z /\ F51.mul_inv_t h z)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.mul_inv_t h1 out /\
F51.fevalh h1 out == F51.fevalh h0 z `SC.fpow` ((SC.prime + 3) / 8)
) | let pow2_252m2 out z =
push_frame();
let buf = create 20ul (u64 0) in
crecip_1 out buf z;
crecip_2 out buf z;
assert_norm (7237005577332262213973186563042994240829374041602535252466099000494570602494 == (SC.prime + 3) / 8);
pop_frame() | {
"file_name": "code/ed25519/Hacl.Impl.Ed25519.Pow2_252m2.fst",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 13,
"end_line": 138,
"start_col": 0,
"start_line": 132
} | module Hacl.Impl.Ed25519.Pow2_252m2
open FStar.HyperStack.All
module ST = FStar.HyperStack.ST
open FStar.Mul
open Lib.IntTypes
open Lib.Buffer
open Hacl.Bignum25519
module F51 = Hacl.Impl.Ed25519.Field51
module SC = Spec.Curve25519
module CI = Hacl.Spec.Curve25519.Finv
#set-options "--z3rlimit 500 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextract
val crecip_1:
out:felem
-> buf:lbuffer uint64 20ul
-> z:felem ->
Stack unit
(requires fun h -> live h out /\ live h buf /\ live h z /\
disjoint buf z /\ disjoint out z /\ disjoint out buf /\
F51.mul_inv_t h z)
(ensures fun h0 _ h1 ->
modifies (loc buf) h0 h1 /\
F51.mul_inv_t h1 (gsub buf 10ul 5ul) /\
F51.felem_fits h1 (gsub buf 5ul 5ul) (1, 2, 1, 1, 1) /\
F51.fevalh h1 (gsub buf 5ul 5ul) == CI.pow (F51.fevalh h0 z) 1267650600228228275596796362752 /\
F51.fevalh h1 (gsub buf 10ul 5ul) == CI.pow (F51.fevalh h0 z) 1125899906842623
)
let crecip_1 out buf z =
let a = sub buf 0ul 5ul in
let t0 = sub buf 5ul 5ul in
let b = sub buf 10ul 5ul in
let c = sub buf 15ul 5ul in
(**) let h0 = ST.get() in
fsquare_times a z 1ul; // a = z ** (2 ** 1) == z ** 2
(**) assert_norm (pow2 1 == 2);
fsquare_times t0 a 2ul; // t0 == a ** (2 ** 2) == (z ** 2) ** 4 == z ** 8
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 2 4;
(**) assert_norm (pow2 2 == 4);
fmul b t0 z; // b == z0 ** 9
(**) CI.lemma_pow_one (F51.fevalh h0 z);
(**) CI.lemma_pow_add (F51.fevalh h0 z) 8 1;
fmul a b a; // a == b * a == z ** 11
(**) CI.lemma_pow_add (F51.fevalh h0 z) 9 2;
fsquare_times t0 a 1ul; // t0 == a ** 2 == z ** 22
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 11 2;
fmul b t0 b; // b == z ** 31
(**) CI.lemma_pow_add (F51.fevalh h0 z) 22 9;
fsquare_times t0 b 5ul; // t0 == b ** (2 ** 5) == z ** 992
(**) assert_norm (pow2 5 == 32);
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 31 32;
fmul b t0 b; // b == t0 * b == z ** 1023
(**) CI.lemma_pow_add (F51.fevalh h0 z) 992 31;
fsquare_times t0 b 10ul; // t0 = b ** (2 ** 1024) == z ** 1047552
(**) assert_norm (pow2 10 == 1024);
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 1023 1024;
fmul c t0 b; // c == z ** 1048575
(**) CI.lemma_pow_add (F51.fevalh h0 z) 1047552 1023;
fsquare_times t0 c 20ul; // t0 == c ** (2 ** 20) == 1099510579200
(**) assert_norm (pow2 20 == 1048576);
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 1048575 1048576;
fmul t0 t0 c; // t0 == z ** 1099511627775
(**) CI.lemma_pow_add (F51.fevalh h0 z) 1099510579200 1048575;
fsquare_times_inplace t0 10ul; // t0 == z ** 1125899906841600
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 1099511627775 1024;
fmul b t0 b; // b == z ** 1125899906842623
(**) CI.lemma_pow_add (F51.fevalh h0 z) 1125899906841600 1023;
fsquare_times t0 b 50ul; // t0 == z ** 1267650600228228275596796362752;
(**) assert_norm (pow2 50 = 1125899906842624);
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 1125899906842623 1125899906842624
inline_for_extraction noextract
val crecip_2:
out:felem
-> buf:lbuffer uint64 20ul
-> z:felem ->
Stack unit
(requires fun h -> live h out /\ live h buf /\ live h z /\
disjoint buf z /\ disjoint out z /\ disjoint out buf /\
F51.mul_inv_t h (gsub buf 10ul 5ul) /\
F51.felem_fits h (gsub buf 5ul 5ul) (1, 2, 1, 1, 1) /\
F51.fevalh h (gsub buf 5ul 5ul) == CI.pow (F51.fevalh h z) 1267650600228228275596796362752 /\
F51.fevalh h (gsub buf 10ul 5ul) == CI.pow (F51.fevalh h z) 1125899906842623 /\
F51.mul_inv_t h z)
(ensures fun h0 _ h1 ->
modifies (loc buf |+| loc out) h0 h1 /\
F51.mul_inv_t h1 out /\
F51.fevalh h1 out == CI.pow (F51.fevalh h0 z) 7237005577332262213973186563042994240829374041602535252466099000494570602494
)
let crecip_2 out buf z =
let a = sub buf 0ul 5ul in
let t0 = sub buf 5ul 5ul in
let b = sub buf 10ul 5ul in
let c = sub buf 15ul 5ul in
let h0 = ST.get() in
(**) assert_norm (pow2 1 == 2);
fsquare_times a z 1ul; // a == z ** 2;
fmul c t0 b; // c == z ** 1267650600228229401496703205375
(**) CI.lemma_pow_add (F51.fevalh h0 z) 1267650600228228275596796362752 1125899906842623;
fsquare_times t0 c 100ul; // t0 == z ** 1606938044258990275541962092339894951921974764381296132096000
(**) assert_norm (pow2 100 = 1267650600228229401496703205376);
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 1267650600228229401496703205375 1267650600228229401496703205376;
fmul t0 t0 c; // t0 == z ** 1606938044258990275541962092341162602522202993782792835301375
(**) CI.lemma_pow_add (F51.fevalh h0 z) 1606938044258990275541962092339894951921974764381296132096000 1267650600228229401496703205375;
(**) assert_norm (pow2 50 == 1125899906842624);
fsquare_times_inplace t0 50ul; // t0 == z ** 1809251394333065553493296640760748560207343510400633813116523624223735808000
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 1606938044258990275541962092341162602522202993782792835301375 1125899906842624;
fmul t0 t0 b; // t0 == z ** 1809251394333065553493296640760748560207343510400633813116524750123642650623
(**) CI.lemma_pow_add (F51.fevalh h0 z) 1809251394333065553493296640760748560207343510400633813116523624223735808000 1125899906842623;
(**) assert_norm (pow2 2 == 4);
fsquare_times_inplace t0 2ul; // t0 == z ** 7237005577332262213973186563042994240829374041602535252466099000494570602492
(**) CI.lemma_pow_mul (F51.fevalh h0 z) 1809251394333065553493296640760748560207343510400633813116524750123642650623 4;
fmul out t0 a;
(**) CI.lemma_pow_add (F51.fevalh h0 z) 7237005577332262213973186563042994240829374041602535252466099000494570602492 2
val pow2_252m2:
out:felem
-> z:felem ->
Stack unit
(requires fun h -> live h out /\ live h z /\ disjoint out z /\ F51.mul_inv_t h z)
(ensures fun h0 _ h1 -> modifies (loc out) h0 h1 /\
F51.mul_inv_t h1 out /\
F51.fevalh h1 out == F51.fevalh h0 z `SC.fpow` ((SC.prime + 3) / 8)
) | {
"checked_file": "/",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.Curve25519.Finv.fst.checked",
"Hacl.Impl.Ed25519.Field51.fst.checked",
"Hacl.Bignum25519.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Ed25519.Pow2_252m2.fst"
} | [
{
"abbrev": true,
"full_module": "Hacl.Spec.Curve25519.Finv",
"short_module": "CI"
},
{
"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.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"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
}
] | {
"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": 500,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | false | out: Hacl.Bignum25519.felem -> z: Hacl.Bignum25519.felem -> FStar.HyperStack.ST.Stack Prims.unit | FStar.HyperStack.ST.Stack | [] | [] | [
"Hacl.Bignum25519.felem",
"FStar.HyperStack.ST.pop_frame",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.op_Division",
"Prims.op_Addition",
"Spec.Curve25519.prime",
"Hacl.Impl.Ed25519.Pow2_252m2.crecip_2",
"Hacl.Impl.Ed25519.Pow2_252m2.crecip_1",
"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",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.u64",
"Lib.Buffer.lbuffer",
"FStar.HyperStack.ST.push_frame"
] | [] | false | true | false | false | false | let pow2_252m2 out z =
| push_frame ();
let buf = create 20ul (u64 0) in
crecip_1 out buf z;
crecip_2 out buf z;
assert_norm (7237005577332262213973186563042994240829374041602535252466099000494570602494 ==
(SC.prime + 3) / 8);
pop_frame () | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_tagged_union_tag | val gaccessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Tot (gaccessor (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data)) | val gaccessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Tot (gaccessor (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data)) | let gaccessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= gaccessor_prop_equiv (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data) (gaccessor_tagged_union_tag' pt tag_of_data p);
gaccessor_tagged_union_tag' pt tag_of_data p | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 46,
"end_line": 1431,
"start_col": 0,
"start_line": 1421
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos
inline_for_extraction
let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos
inline_for_extraction
let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
inline_for_extraction
let jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
let clens_tagged_union_tag
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t)
= {
clens_cond = (fun _ -> True);
clens_get = tag_of_data;
}
let gaccessor_tagged_union_tag'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= fun input ->
parse_tagged_union_eq pt tag_of_data p input;
0 | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
pt: LowParse.Spec.Base.parser kt tag_t ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
p: (t: tag_t -> LowParse.Spec.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t))
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.Combinators.parse_tagged_union pt tag_of_data p
)
pt
(LowParse.Low.Combinators.clens_tagged_union_tag tag_of_data) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Low.Combinators.gaccessor_tagged_union_tag'",
"Prims.unit",
"LowParse.Low.Base.Spec.gaccessor_prop_equiv",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_tagged_union",
"LowParse.Low.Combinators.clens_tagged_union_tag",
"LowParse.Low.Base.Spec.gaccessor"
] | [] | false | false | false | false | false | let gaccessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Tot (gaccessor (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data)) =
| gaccessor_prop_equiv (parse_tagged_union pt tag_of_data p)
pt
(clens_tagged_union_tag tag_of_data)
(gaccessor_tagged_union_tag' pt tag_of_data p);
gaccessor_tagged_union_tag' pt tag_of_data p | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_weaken | val validate_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2)) | val validate_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2)) | let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 1338,
"start_col": 0,
"start_line": 1324
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
k1: LowParse.Spec.Base.parser_kind ->
v2: LowParse.Low.Base.validator p2 ->
sq: Prims.squash (LowParse.Spec.Base.is_weaker_than k1 k2)
-> LowParse.Low.Base.validator (LowParse.Spec.Base.weaken k1 p2) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.squash",
"LowParse.Spec.Base.is_weaker_than",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"LowParse.Spec.Base.weaken",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | false | false | false | false | let validate_weaken
(k1 #k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@@ inline_let ]let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.clens_tagged_union_payload | val clens_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(t: tag_t)
: Tot (clens data_t (refine_with_tag tag_of_data t)) | val clens_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(t: tag_t)
: Tot (clens data_t (refine_with_tag tag_of_data t)) | let clens_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(t: tag_t)
: Tot (clens data_t (refine_with_tag tag_of_data t))
= {
clens_cond = (fun d -> tag_of_data d == t);
clens_get = (fun (d: data_t) -> (d <: refine_with_tag tag_of_data t));
} | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 3,
"end_line": 1457,
"start_col": 0,
"start_line": 1448
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos
inline_for_extraction
let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos
inline_for_extraction
let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
inline_for_extraction
let jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
let clens_tagged_union_tag
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t)
= {
clens_cond = (fun _ -> True);
clens_get = tag_of_data;
}
let gaccessor_tagged_union_tag'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= fun input ->
parse_tagged_union_eq pt tag_of_data p input;
0
let gaccessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= gaccessor_prop_equiv (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data) (gaccessor_tagged_union_tag' pt tag_of_data p);
gaccessor_tagged_union_tag' pt tag_of_data p
inline_for_extraction
let accessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (accessor (gaccessor_tagged_union_tag pt tag_of_data p))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_tagged_union_tag pt tag_of_data p) input pos in
pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false | tag_of_data: (_: data_t -> Prims.GTot tag_t) -> t: tag_t
-> LowParse.Low.Base.Spec.clens data_t (LowParse.Spec.Base.refine_with_tag tag_of_data t) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Low.Base.Spec.Mkclens",
"LowParse.Spec.Base.refine_with_tag",
"Prims.eq2",
"LowParse.Low.Base.Spec.clens"
] | [] | false | false | false | false | false | let clens_tagged_union_payload
(#tag_t #data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(t: tag_t)
: Tot (clens data_t (refine_with_tag tag_of_data t)) =
| {
clens_cond = (fun d -> tag_of_data d == t);
clens_get = (fun (d: data_t) -> (d <: refine_with_tag tag_of_data t))
} | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_tagged_union_payload | val gaccessor_tagged_union_payload
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(t: tag_t)
: Tot
(gaccessor (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)) | val gaccessor_tagged_union_payload
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(t: tag_t)
: Tot
(gaccessor (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)) | let gaccessor_tagged_union_payload
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(t: tag_t)
: Tot (gaccessor (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_tagged_union_payload_injective pt tag_of_data p t x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_tagged_union_payload_no_lookahead pt tag_of_data p t x));
gaccessor_prop_equiv (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) (gaccessor_tagged_union_payload' pt tag_of_data p t);
gaccessor_tagged_union_payload' pt tag_of_data p t | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 52,
"end_line": 1538,
"start_col": 0,
"start_line": 1525
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos
inline_for_extraction
let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos
inline_for_extraction
let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
inline_for_extraction
let jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
let clens_tagged_union_tag
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t)
= {
clens_cond = (fun _ -> True);
clens_get = tag_of_data;
}
let gaccessor_tagged_union_tag'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= fun input ->
parse_tagged_union_eq pt tag_of_data p input;
0
let gaccessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= gaccessor_prop_equiv (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data) (gaccessor_tagged_union_tag' pt tag_of_data p);
gaccessor_tagged_union_tag' pt tag_of_data p
inline_for_extraction
let accessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (accessor (gaccessor_tagged_union_tag pt tag_of_data p))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_tagged_union_tag pt tag_of_data p) input pos in
pos
let clens_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(t: tag_t)
: Tot (clens data_t (refine_with_tag tag_of_data t))
= {
clens_cond = (fun d -> tag_of_data d == t);
clens_get = (fun (d: data_t) -> (d <: refine_with_tag tag_of_data t));
}
let gaccessor_tagged_union_payload'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(t: tag_t)
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t))
= fun input ->
parse_tagged_union_eq pt tag_of_data p input;
match parse pt input with
| Some (t', consumed_t) ->
consumed_t
| _ -> 0 (* dummy *)
let gaccessor_tagged_union_payload_injective
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(t: tag_t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl' /\
injective_precond (parse_tagged_union pt tag_of_data p) sl sl'
))
(ensures (
gaccessor_tagged_union_payload' pt tag_of_data p t sl == gaccessor_tagged_union_payload' pt tag_of_data p t sl'
))
= parse_injective (parse_tagged_union pt tag_of_data p) sl sl' ;
parse_tagged_union_eq pt tag_of_data p sl ;
parse_tagged_union_eq pt tag_of_data p sl' ;
parse_injective pt sl sl'
let gaccessor_tagged_union_payload_no_lookahead
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(t: tag_t)
(sl sl' : bytes)
: Lemma
(requires (
(and_then_kind kt k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl' /\
no_lookahead_on_precond (parse_tagged_union pt tag_of_data p) sl sl'
))
(ensures (
gaccessor_tagged_union_payload' pt tag_of_data p t sl == gaccessor_tagged_union_payload' pt tag_of_data p t sl'
))
= parse_strong_prefix (parse_tagged_union pt tag_of_data p) sl sl' ;
parse_tagged_union_eq pt tag_of_data p sl ;
parse_tagged_union_eq pt tag_of_data p sl' ;
parse_injective pt sl sl' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
pt: LowParse.Spec.Base.parser kt tag_t ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
p: (t: tag_t -> LowParse.Spec.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) ->
t: tag_t
-> LowParse.Low.Base.Spec.gaccessor (LowParse.Spec.Combinators.parse_tagged_union pt tag_of_data p
)
(p t)
(LowParse.Low.Combinators.clens_tagged_union_payload tag_of_data t) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Low.Combinators.gaccessor_tagged_union_payload'",
"Prims.unit",
"LowParse.Low.Base.Spec.gaccessor_prop_equiv",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_tagged_union",
"LowParse.Low.Combinators.clens_tagged_union_payload",
"FStar.Classical.forall_intro_2",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"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.Base.no_lookahead_on_precond",
"Prims.nat",
"FStar.Classical.move_requires",
"LowParse.Low.Combinators.gaccessor_tagged_union_payload_no_lookahead",
"Prims.l_True",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Spec.Base.injective_precond",
"LowParse.Low.Combinators.gaccessor_tagged_union_payload_injective",
"LowParse.Low.Base.Spec.gaccessor"
] | [] | false | false | false | false | false | let gaccessor_tagged_union_payload
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(t: tag_t)
: Tot
(gaccessor (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)) =
| Classical.forall_intro_2 (fun x ->
Classical.move_requires (gaccessor_tagged_union_payload_injective pt tag_of_data p t x));
Classical.forall_intro_2 (fun x ->
Classical.move_requires (gaccessor_tagged_union_payload_no_lookahead pt tag_of_data p t x));
gaccessor_prop_equiv (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
(gaccessor_tagged_union_payload' pt tag_of_data p t);
gaccessor_tagged_union_payload' pt tag_of_data p t | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.validate_strengthen | val validate_strengthen
(k2 #k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1)) | val validate_strengthen
(k2 #k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1)) | let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 14,
"end_line": 1372,
"start_col": 0,
"start_line": 1358
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
k2: LowParse.Spec.Base.parser_kind ->
v1: LowParse.Low.Base.validator p1 ->
sq: Prims.squash (LowParse.Spec.Base.parser_kind_prop k2 p1)
-> LowParse.Low.Base.validator (LowParse.Spec.Base.strengthen k2 p1) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.validator",
"Prims.squash",
"LowParse.Spec.Base.parser_kind_prop",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt64.t",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.ErrorCode.uint64_to_uint32",
"LowParse.Spec.Base.strengthen",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get"
] | [] | false | false | false | false | false | let validate_strengthen
(k2 #k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1)) =
| fun #rrel #rel input pos ->
let h = HST.get () in
[@@ inline_let ]let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@@ inline_let ]let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_tagged_union_payload_no_lookahead | val gaccessor_tagged_union_payload_no_lookahead
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(t: tag_t)
(sl sl': bytes)
: Lemma
(requires
((and_then_kind kt k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl' /\ no_lookahead_on_precond (parse_tagged_union pt tag_of_data p) sl sl'))
(ensures
(gaccessor_tagged_union_payload' pt tag_of_data p t sl ==
gaccessor_tagged_union_payload' pt tag_of_data p t sl')) | val gaccessor_tagged_union_payload_no_lookahead
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(t: tag_t)
(sl sl': bytes)
: Lemma
(requires
((and_then_kind kt k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl' /\ no_lookahead_on_precond (parse_tagged_union pt tag_of_data p) sl sl'))
(ensures
(gaccessor_tagged_union_payload' pt tag_of_data p t sl ==
gaccessor_tagged_union_payload' pt tag_of_data p t sl')) | let gaccessor_tagged_union_payload_no_lookahead
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(t: tag_t)
(sl sl' : bytes)
: Lemma
(requires (
(and_then_kind kt k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl' /\
no_lookahead_on_precond (parse_tagged_union pt tag_of_data p) sl sl'
))
(ensures (
gaccessor_tagged_union_payload' pt tag_of_data p t sl == gaccessor_tagged_union_payload' pt tag_of_data p t sl'
))
= parse_strong_prefix (parse_tagged_union pt tag_of_data p) sl sl' ;
parse_tagged_union_eq pt tag_of_data p sl ;
parse_tagged_union_eq pt tag_of_data p sl' ;
parse_injective pt sl sl' | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 1523,
"start_col": 0,
"start_line": 1500
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos
inline_for_extraction
let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos
inline_for_extraction
let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
inline_for_extraction
let jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
let clens_tagged_union_tag
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t)
= {
clens_cond = (fun _ -> True);
clens_get = tag_of_data;
}
let gaccessor_tagged_union_tag'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= fun input ->
parse_tagged_union_eq pt tag_of_data p input;
0
let gaccessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= gaccessor_prop_equiv (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data) (gaccessor_tagged_union_tag' pt tag_of_data p);
gaccessor_tagged_union_tag' pt tag_of_data p
inline_for_extraction
let accessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (accessor (gaccessor_tagged_union_tag pt tag_of_data p))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_tagged_union_tag pt tag_of_data p) input pos in
pos
let clens_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(t: tag_t)
: Tot (clens data_t (refine_with_tag tag_of_data t))
= {
clens_cond = (fun d -> tag_of_data d == t);
clens_get = (fun (d: data_t) -> (d <: refine_with_tag tag_of_data t));
}
let gaccessor_tagged_union_payload'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(t: tag_t)
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t))
= fun input ->
parse_tagged_union_eq pt tag_of_data p input;
match parse pt input with
| Some (t', consumed_t) ->
consumed_t
| _ -> 0 (* dummy *)
let gaccessor_tagged_union_payload_injective
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(t: tag_t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl' /\
injective_precond (parse_tagged_union pt tag_of_data p) sl sl'
))
(ensures (
gaccessor_tagged_union_payload' pt tag_of_data p t sl == gaccessor_tagged_union_payload' pt tag_of_data p t sl'
))
= parse_injective (parse_tagged_union pt tag_of_data p) sl sl' ;
parse_tagged_union_eq pt tag_of_data p sl ;
parse_tagged_union_eq pt tag_of_data p sl' ;
parse_injective pt sl sl' | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
pt: LowParse.Spec.Base.parser kt tag_t ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
p: (t: tag_t -> LowParse.Spec.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) ->
t: tag_t ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind (LowParse.Spec.Combinators.and_then_kind kt k) ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Combinators.parse_tagged_union pt
tag_of_data
p)
(p t)
(LowParse.Low.Combinators.clens_tagged_union_payload tag_of_data t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Combinators.parse_tagged_union pt
tag_of_data
p)
(p t)
(LowParse.Low.Combinators.clens_tagged_union_payload tag_of_data t)
sl' /\
LowParse.Spec.Base.no_lookahead_on_precond (LowParse.Spec.Combinators.parse_tagged_union pt
tag_of_data
p)
sl
sl')
(ensures
LowParse.Low.Combinators.gaccessor_tagged_union_payload' pt tag_of_data p t sl ==
LowParse.Low.Combinators.gaccessor_tagged_union_payload' pt tag_of_data p t sl') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Combinators.parse_tagged_union_eq",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_tagged_union",
"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.Combinators.clens_tagged_union_payload",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.squash",
"Prims.nat",
"LowParse.Low.Combinators.gaccessor_tagged_union_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let gaccessor_tagged_union_payload_no_lookahead
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(t: tag_t)
(sl sl': bytes)
: Lemma
(requires
((and_then_kind kt k).parser_kind_subkind == Some ParserStrong /\
gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl' /\ no_lookahead_on_precond (parse_tagged_union pt tag_of_data p) sl sl'))
(ensures
(gaccessor_tagged_union_payload' pt tag_of_data p t sl ==
gaccessor_tagged_union_payload' pt tag_of_data p t sl')) =
| parse_strong_prefix (parse_tagged_union pt tag_of_data p) sl sl';
parse_tagged_union_eq pt tag_of_data p sl;
parse_tagged_union_eq pt tag_of_data p sl';
parse_injective pt sl sl' | false |
Vale.Wrapper.X64.GCMdecryptOpt256.fsti | Vale.Wrapper.X64.GCMdecryptOpt256.uint8_p | val uint8_p : Type0 | let uint8_p = B.buffer UInt8.t | {
"file_name": "vale/code/arch/x64/interop/Vale.Wrapper.X64.GCMdecryptOpt256.fsti",
"git_rev": "eb1badfa34c70b0bbe0fe24fe0f49fb1295c7872",
"git_url": "https://github.com/project-everest/hacl-star.git",
"project_name": "hacl-star"
} | {
"end_col": 30,
"end_line": 24,
"start_col": 0,
"start_line": 24
} | module Vale.Wrapper.X64.GCMdecryptOpt256
open Vale.X64.CPU_Features_s
open FStar.HyperStack.ST
module B = LowStar.Buffer
module HS = FStar.HyperStack
module DV = LowStar.BufferView.Down
module UV = LowStar.BufferView.Up
open Vale.AsLowStar.MemoryHelpers
open FStar.Mul
open Vale.Def.Words_s
open Vale.Def.Words.Seq_s
open Vale.Def.Types_s
open Vale.AES.GCM_helpers
open Vale.AES.AES_s
open Vale.AES.GCM_s
open Vale.AES.GHash_s
open Vale.AES.GCTR_s
open Vale.AES.GCTR
open Vale.Interop.Base
open Vale.Arch.Types
open Vale.AES.OptPublic | {
"checked_file": "/",
"dependencies": [
"Vale.X64.CPU_Features_s.fst.checked",
"Vale.Wrapper.X64.GCMdecryptOpt.fsti.checked",
"Vale.Interop.Base.fst.checked",
"Vale.Def.Words_s.fsti.checked",
"Vale.Def.Words.Seq_s.fsti.checked",
"Vale.Def.Types_s.fst.checked",
"Vale.AsLowStar.MemoryHelpers.fsti.checked",
"Vale.Arch.Types.fsti.checked",
"Vale.AES.OptPublic.fsti.checked",
"Vale.AES.GHash_s.fst.checked",
"Vale.AES.GCTR_s.fst.checked",
"Vale.AES.GCTR.fsti.checked",
"Vale.AES.GCM_s.fst.checked",
"Vale.AES.GCM_helpers.fsti.checked",
"Vale.AES.AES_s.fst.checked",
"prims.fst.checked",
"LowStar.BufferView.Up.fsti.checked",
"LowStar.BufferView.Down.fsti.checked",
"LowStar.Buffer.fst.checked",
"FStar.UInt8.fsti.checked",
"FStar.UInt64.fsti.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked"
],
"interface_file": false,
"source_file": "Vale.Wrapper.X64.GCMdecryptOpt256.fsti"
} | [
{
"abbrev": false,
"full_module": "Vale.AES.OptPublic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Types",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Interop.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCTR_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GHash_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.AES_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AES.GCM_helpers",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Types_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words.Seq_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Words_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.AsLowStar.MemoryHelpers",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Up",
"short_module": "UV"
},
{
"abbrev": true,
"full_module": "LowStar.BufferView.Down",
"short_module": "DV"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.ST",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.X64.CPU_Features_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Wrapper.X64",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Wrapper.X64",
"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
}
] | {
"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"
} | false | Type0 | Prims.Tot | [
"total"
] | [] | [
"LowStar.Buffer.buffer",
"FStar.UInt8.t"
] | [] | false | false | false | true | true | let uint8_p =
| B.buffer UInt8.t | false |
|
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_tagged_union_payload_injective | val gaccessor_tagged_union_payload_injective
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(t: tag_t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl' /\ injective_precond (parse_tagged_union pt tag_of_data p) sl sl'))
(ensures
(gaccessor_tagged_union_payload' pt tag_of_data p t sl ==
gaccessor_tagged_union_payload' pt tag_of_data p t sl')) | val gaccessor_tagged_union_payload_injective
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(t: tag_t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl' /\ injective_precond (parse_tagged_union pt tag_of_data p) sl sl'))
(ensures
(gaccessor_tagged_union_payload' pt tag_of_data p t sl ==
gaccessor_tagged_union_payload' pt tag_of_data p t sl')) | let gaccessor_tagged_union_payload_injective
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(t: tag_t)
(sl sl' : bytes)
: Lemma
(requires (
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t) sl' /\
injective_precond (parse_tagged_union pt tag_of_data p) sl sl'
))
(ensures (
gaccessor_tagged_union_payload' pt tag_of_data p t sl == gaccessor_tagged_union_payload' pt tag_of_data p t sl'
))
= parse_injective (parse_tagged_union pt tag_of_data p) sl sl' ;
parse_tagged_union_eq pt tag_of_data p sl ;
parse_tagged_union_eq pt tag_of_data p sl' ;
parse_injective pt sl sl' | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 27,
"end_line": 1498,
"start_col": 0,
"start_line": 1476
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos
inline_for_extraction
let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos
inline_for_extraction
let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
inline_for_extraction
let jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
let clens_tagged_union_tag
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t)
= {
clens_cond = (fun _ -> True);
clens_get = tag_of_data;
}
let gaccessor_tagged_union_tag'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= fun input ->
parse_tagged_union_eq pt tag_of_data p input;
0
let gaccessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= gaccessor_prop_equiv (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data) (gaccessor_tagged_union_tag' pt tag_of_data p);
gaccessor_tagged_union_tag' pt tag_of_data p
inline_for_extraction
let accessor_tagged_union_tag
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (accessor (gaccessor_tagged_union_tag pt tag_of_data p))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_tagged_union_tag pt tag_of_data p) input pos in
pos
let clens_tagged_union_payload
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(t: tag_t)
: Tot (clens data_t (refine_with_tag tag_of_data t))
= {
clens_cond = (fun d -> tag_of_data d == t);
clens_get = (fun (d: data_t) -> (d <: refine_with_tag tag_of_data t));
}
let gaccessor_tagged_union_payload'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
(t: tag_t)
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) (p t) (clens_tagged_union_payload tag_of_data t))
= fun input ->
parse_tagged_union_eq pt tag_of_data p input;
match parse pt input with
| Some (t', consumed_t) ->
consumed_t
| _ -> 0 (* dummy *) | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
pt: LowParse.Spec.Base.parser kt tag_t ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
p: (t: tag_t -> LowParse.Spec.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t)) ->
t: tag_t ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Combinators.parse_tagged_union pt
tag_of_data
p)
(p t)
(LowParse.Low.Combinators.clens_tagged_union_payload tag_of_data t)
sl /\
LowParse.Low.Base.Spec.gaccessor_pre (LowParse.Spec.Combinators.parse_tagged_union pt
tag_of_data
p)
(p t)
(LowParse.Low.Combinators.clens_tagged_union_payload tag_of_data t)
sl' /\
LowParse.Spec.Base.injective_precond (LowParse.Spec.Combinators.parse_tagged_union pt
tag_of_data
p)
sl
sl')
(ensures
LowParse.Low.Combinators.gaccessor_tagged_union_payload' pt tag_of_data p t sl ==
LowParse.Low.Combinators.gaccessor_tagged_union_payload' pt tag_of_data p t sl') | FStar.Pervasives.Lemma | [
"lemma"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_injective",
"Prims.unit",
"LowParse.Spec.Combinators.parse_tagged_union_eq",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_tagged_union",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Low.Combinators.clens_tagged_union_payload",
"LowParse.Spec.Base.injective_precond",
"Prims.squash",
"Prims.eq2",
"Prims.nat",
"LowParse.Low.Combinators.gaccessor_tagged_union_payload'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | true | false | true | false | false | let gaccessor_tagged_union_payload_injective
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
(t: tag_t)
(sl sl': bytes)
: Lemma
(requires
(gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl /\
gaccessor_pre (parse_tagged_union pt tag_of_data p)
(p t)
(clens_tagged_union_payload tag_of_data t)
sl' /\ injective_precond (parse_tagged_union pt tag_of_data p) sl sl'))
(ensures
(gaccessor_tagged_union_payload' pt tag_of_data p t sl ==
gaccessor_tagged_union_payload' pt tag_of_data p t sl')) =
| parse_injective (parse_tagged_union pt tag_of_data p) sl sl';
parse_tagged_union_eq pt tag_of_data p sl;
parse_tagged_union_eq pt tag_of_data p sl';
parse_injective pt sl sl' | false |
LowParse.Low.Combinators.fsti | LowParse.Low.Combinators.gaccessor_tagged_union_tag' | val gaccessor_tagged_union_tag'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data)) | val gaccessor_tagged_union_tag'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data)) | let gaccessor_tagged_union_tag'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t) -> Tot (parser k (refine_with_tag tag_of_data t)))
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data))
= fun input ->
parse_tagged_union_eq pt tag_of_data p input;
0 | {
"file_name": "src/lowparse/LowParse.Low.Combinators.fsti",
"git_rev": "00217c4a89f5ba56002ba9aa5b4a9d5903bfe9fa",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | {
"end_col": 5,
"end_line": 1419,
"start_col": 0,
"start_line": 1408
} | module LowParse.Low.Combinators
include LowParse.Low.Base
include LowParse.Spec.Combinators
module B = LowStar.Monotonic.Buffer
module B0 = LowStar.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
#set-options "--z3rlimit 16"
let valid_nondep_then
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (nondep_then p1 p2) h s pos \/
(valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
valid p2 h s (get_valid_pos p1 h s pos) /\
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (nondep_then p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
nondep_then_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
valid_facts p2 h s pos1
end
end
let valid_nondep_then_intro
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p1 h s pos /\ valid p2 h s (get_valid_pos p1 h s pos)))
(ensures ((
let pos1 = get_valid_pos p1 h s pos in
valid_content_pos (nondep_then p1 p2) h s pos (contents p1 h s pos, contents p2 h s pos1) (get_valid_pos p2 h s pos1)
)))
= valid_nondep_then h p1 p2 s pos
inline_for_extraction
let validate_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : validator p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : validator p2)
: Tot (validator (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = p1' input pos in
if is_error pos1
then begin
pos1
end
else
[@inline_let] let _ = valid_facts p2 h input (uint64_to_uint32 pos1) in
p2' input pos1
inline_for_extraction
let jump_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(p2' : jumper p2)
: Tot (jumper (nondep_then p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
p2' input (p1' input pos)
inline_for_extraction
let read_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(p1' : jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(r2: leaf_reader p2)
: Tot (leaf_reader (nondep_then p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = p1' sl pos in
let x2 = r2 sl pos2 in
(x1, x2)
inline_for_extraction
let serialize32_nondep_then_aux
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
(x1: t1)
(x2: t2)
(#rrel: _) (#rel: _)
(b: B.mbuffer byte rrel rel)
(pos: U32.t)
: HST.Stack U32.t
(requires (fun h ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
let len = len1 + len2 in
let sq = B.as_seq h b in
B.live h b /\
U32.v pos + len <= B.length b /\
writable b (U32.v pos) (U32.v pos + len) h
))
(ensures (fun h len h' ->
let len1 = Seq.length (serialize s1 x1) in
let len2 = Seq.length (serialize s2 x2) in
len1 + len2 == U32.v len /\ (
B.modifies (B.loc_buffer_from_to b pos (pos `U32.add` len)) h h' /\
B.live h b /\
Seq.slice (B.as_seq h' b) (U32.v pos) (U32.v pos + U32.v len) `Seq.equal` (serialize s1 x1 `Seq.append` serialize s2 x2)
)))
=
let gpos' = Ghost.hide (pos `U32.add` U32.uint_to_t (Seq.length (serialize s1 x1) + Seq.length (serialize s2 x2))) in
let len1 = frame_serializer32 s1' x1 b (Ghost.hide pos) gpos' pos in
let pos1 = pos `U32.add` len1 in
let len2 = frame_serializer32 s2' x2 b (Ghost.hide pos) gpos' pos1 in
let h1 = HST.get () in
len1 `U32.add` len2
inline_for_extraction
let serialize32_nondep_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong })
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#s2: serializer p2)
(s2' : serializer32 s2)
: Tot (serializer32 (s1 `serialize_nondep_then` s2))
= fun x #rrel #rel b pos ->
[@inline_let]
let (x1, x2) = x in
serialize_nondep_then_eq s1 s2 x;
serialize32_nondep_then_aux s1' s2' x1 x2 b pos
let valid_synth
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
live_slice h input /\ synth_injective f2
))
(ensures (
(valid (parse_synth p1 f2) h input pos \/ valid p1 h input pos) ==> (
valid p1 h input pos /\
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
)))
= valid_facts p1 h input pos;
valid_facts (parse_synth p1 f2) h input pos;
if U32.v pos <= U32.v input.len
then parse_synth_eq p1 f2 (bytes_of_slice_from h input pos)
let valid_synth_intro
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
synth_injective f2 /\
valid p1 h input pos
))
(ensures (
valid_content_pos (parse_synth p1 f2) h input pos (f2 (contents p1 h input pos)) (get_valid_pos p1 h input pos)
))
= valid_synth h p1 f2 input pos
inline_for_extraction
let validate_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : validator p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (validator (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input (uint64_to_uint32 pos) in
p1' input pos
inline_for_extraction
let jump_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(#p1: parser k t1)
(p1' : jumper p1)
(f2: t1 -> GTot t2)
(u: unit {
synth_injective f2
})
: Tot (jumper (parse_synth p1 f2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
p1' input pos
let valid_dtuple2
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (live_slice h s))
(ensures ((
valid (parse_dtuple2 p1 p2) h s pos \/
(valid p1 h s pos /\ valid (p2 (contents p1 h s pos)) h s (get_valid_pos p1 h s pos))
) ==> (
valid p1 h s pos /\ (
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid (p2 x) h s (get_valid_pos p1 h s pos) /\
valid_content_pos (parse_dtuple2 p1 p2) h s pos (| x, contents (p2 x) h s pos1 |) (get_valid_pos (p2 x) h s pos1)
))))
= valid_facts p1 h s pos;
valid_facts (parse_dtuple2 p1 p2) h s pos;
if U32.v pos <= U32.v s.len
then begin
parse_dtuple2_eq p1 p2 (bytes_of_slice_from h s pos);
if valid_dec p1 h s pos
then begin
let pos1 = get_valid_pos p1 h s pos in
let x = contents p1 h s pos in
valid_facts (p2 x) h s pos1
end
end
inline_for_extraction
let validate_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (validator (p2 x)))
: Tot (validator (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input (uint64_to_uint32 pos) in
let pos1 = v1 input pos in
if is_error pos1
then begin
pos1
end
else
let x = r1 input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (p2 x) h input (uint64_to_uint32 pos1) in
v2 x input pos1
inline_for_extraction
let jump_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(v2: (x: t1) -> Tot (jumper (p2 x)))
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
let x = r1 input pos in
[@inline_let] let _ = valid_facts (p2 x) h input pos1 in
v2 x input pos1
inline_for_extraction
let jump_dtuple2_constant_size_dsnd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(p2: (x: t1) -> parser k2 (t2 x))
(sz: U32.t { U32.v sz == k2.parser_kind_low /\ k2.parser_kind_high == Some k2.parser_kind_low })
: Tot (jumper (parse_dtuple2 p1 p2))
= fun (#rrel #rel: _)
(input: slice rrel rel) (pos: U32.t) ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 input pos in
let pos1 = v1 input pos in
[@inline_let] let p2x = Ghost.hide (p2 (contents p1 h input pos)) in
[@inline_let] let _ = valid_facts (Ghost.reveal p2x) h input pos1 in
jump_constant_size' (fun _ -> Ghost.reveal p2x) sz () input pos1
inline_for_extraction
let read_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: jumper p1)
(r1: leaf_reader p1)
(#k2: parser_kind)
(#t2: t1 -> Type)
(#p2: (x: t1) -> parser k2 (t2 x))
(r2: (x: t1) -> Tot (leaf_reader (p2 x)))
: Tot (leaf_reader (parse_dtuple2 p1 p2))
= fun #_ #_ sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_dtuple2 h p1 p2 sl pos in
let x1 = r1 sl pos in
let pos2 = v1 sl pos in
let x2 = r2 x1 sl pos2 in
(| x1, x2 |)
inline_for_extraction
let serialize32_dtuple2
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#s1: serializer p1)
(s1' : serializer32 s1 { k1.parser_kind_subkind == Some ParserStrong } )
(#k2: parser_kind)
(#t2: t1 -> Tot Type)
(#p2: (x: t1) -> Tot (parser k2 (t2 x)))
(#s2: (x: t1) -> Tot (serializer (p2 x)))
(s2' : (x: t1) -> serializer32 (s2 x))
: Tot (serializer32 (serialize_dtuple2 s1 s2))
= fun (x: dtuple2 t1 t2) #_ #_ b pos ->
[@inline_let]
let _ = serialize_dtuple2_eq s1 s2 x in
match x with
| (| x1, x2 |) ->
serialize32_nondep_then_aux s1' (s2' x1) x1 x2 b pos
inline_for_extraction
let validate_ret
(#t: Type)
(v: t)
: Tot (validator (parse_ret v))
= validate_total_constant_size (parse_ret v) 0uL ()
inline_for_extraction
let validate_empty () : Tot (validator parse_empty)
= validate_ret ()
inline_for_extraction
let validate_false () : Tot (validator parse_false)
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts parse_false h input (uint64_to_uint32 pos) in
validator_error_generic
inline_for_extraction
let jump_empty : jumper parse_empty
= jump_constant_size parse_empty 0ul ()
inline_for_extraction
let jump_false : jumper parse_false
= jump_constant_size parse_false 0ul ()
inline_for_extraction
let read_ret
(#t: Type)
(v: t)
: Tot (leaf_reader (parse_ret v))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (parse_ret v) h sl pos in
v
inline_for_extraction
let read_empty : leaf_reader parse_empty = read_ret ()
inline_for_extraction
let read_false : leaf_reader parse_false = fun #rrel #rel sl pos ->
LowStar.Failure.failwith "read_false: should not be called"
inline_for_extraction
let serialize32_ret
(#t: Type)
(v: t)
(v_unique: (v' : t) -> Lemma (v == v'))
: Tot (serializer32 (serialize_ret v v_unique))
= fun _ #_ #_ _ _ -> 0ul
inline_for_extraction
let serialize32_empty : serializer32 #_ #_ #parse_empty serialize_empty
= serialize32_ret () (fun _ -> ())
inline_for_extraction
let serialize32_false : serializer32 #_ #_ #parse_false serialize_false
= fun _ #_ #_ _ _ -> 0ul // dummy
let valid_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(h: HS.mem)
#rrel #rel
(input: slice rrel rel)
(pos: U32.t)
: Lemma
((valid (lift_parser p) h input pos \/ valid (p ()) h input pos) ==>
valid (p ()) h input pos /\
valid_content_pos (lift_parser p) h input pos (contents (p ()) h input pos) (get_valid_pos (p ()) h input pos))
= valid_facts (p ()) h input pos;
valid_facts (lift_parser p) h input pos
inline_for_extraction
let validate_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: validator #k #t (p ()))
: Tot (validator #k #t (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input (uint64_to_uint32 pos);
v input pos
inline_for_extraction
let jump_lift_parser
(#k: parser_kind)
(#t: Type)
(p: unit -> Tot (parser k t))
(v: jumper (p ()))
: Tot (jumper (lift_parser p))
= fun #rrel #rel input pos ->
let h = HST.get () in
valid_lift_parser p h input pos;
v input pos
let clens_synth
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t1 t2)
= {
clens_cond = (fun (x: t1) -> True);
clens_get = (fun (x: t1) -> f x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (parse_synth p1 f) p1 (clens_synth g f) input pos'))
= synth_injective_synth_inverse_synth_inverse_recip f g ();
parse_synth_eq p1 f input;
0
val gaccessor_synth
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor (parse_synth p1 f) p1 (clens_synth g f))
val gaccessor_synth_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth p1 f g u input == gaccessor_synth' p1 f g u input)
inline_for_extraction
let accessor_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_eq p1 f g u);
slice_access_eq h (gaccessor_synth p1 f g u) input pos
in
pos
let clens_synth_inv
(#t1: Type)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
: Tot (clens t2 t1)
= {
clens_cond = (fun (x: t2) -> True);
clens_get = (fun (x: t2) -> g x);
(*
clens_put = (fun (x: t1) (y: t2) -> g y);
clens_get_put = (fun (x: t1) (y: t2) -> ());
clens_put_put = (fun (x: t1) (y y' : t2) -> ());
clens_put_get = (fun (x: t1) -> ());
*)
}
let gaccessor_synth_inv'
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' p1 (parse_synth p1 f) (clens_synth_inv g f) input pos'))
= parse_synth_eq p1 f input;
0
val gaccessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: squash (synth_inverse f g /\ synth_injective f))
: Tot (gaccessor p1 (parse_synth p1 f) (clens_synth_inv g f))
val gaccessor_synth_inv_eq
(#k: parser_kind)
(#t1: Type)
(p1: parser k t1)
(#t2: Type)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
(input: bytes)
: Lemma
(gaccessor_synth_inv p1 f g u input == gaccessor_synth_inv' p1 f g u input)
inline_for_extraction
let accessor_synth_inv
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f: t1 -> GTot t2)
(g: t2 -> GTot t1)
(u: unit { synth_inverse f g /\ synth_injective f } )
: Tot (accessor (gaccessor_synth_inv p1 f g u))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ =
Classical.forall_intro (gaccessor_synth_inv_eq p1 f g u);
slice_access_eq h (gaccessor_synth_inv p1 f g u) input pos
in
pos
let clens_fst
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t1)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = fst;
(*
clens_put = (fun x y -> (y, snd x));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let clens_snd
(t1: Type)
(t2: Type)
: Tot (clens (t1 & t2) t2)
= {
clens_cond = (fun (x: (t1 & t2)) -> True);
clens_get = snd;
(*
clens_put = (fun x y -> (fst x, y));
clens_get_put = (fun x y -> ());
clens_put_put = (fun x y y' -> ());
clens_put_get = (fun x -> ());
*)
}
let gaccessor_fst'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p1 (clens_fst _ _) input pos'))
= nondep_then_eq p1 p2 input;
0
[@"opaque_to_smt"]
let gaccessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p1 (clens_fst _ _))
= gaccessor_prop_equiv (p1 `nondep_then` p2) p1 (clens_fst _ _) (gaccessor_fst' p1 sq p2);
gaccessor_fst' p1 sq p2
let gaccessor_fst_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_fst p1 sq p2 input == gaccessor_fst' p1 sq p2 input)
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2 input)
let gaccessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(g: gaccessor p1 p' cl)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (gaccessor (p1 `nondep_then` p2) p' (clens_fst _ _ `clens_compose` cl))
= gaccessor_fst p1 u p2 `gaccessor_compose` g
let gaccessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p1 (cl `clens_compose` clens_fst _ _))
= g `gaccessor_compose` gaccessor_fst _ () _
let gaccessor_snd'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Ghost (nat)
(requires (True))
(ensures (fun pos' -> gaccessor_post' (p1 `nondep_then` p2) p2 (clens_snd _ _) input pos'))
= nondep_then_eq p1 p2 input;
match parse p1 input with
| None -> 0 // dummy
| Some (_, consumed) -> consumed
let gaccessor_snd_injective
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires (gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ injective_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl';
parse_injective p1 sl sl'
let gaccessor_snd_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(sl sl' : bytes)
: Lemma
(requires ((and_then_kind k1 k2).parser_kind_subkind == Some ParserStrong /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ gaccessor_pre (p1 `nondep_then` p2) p2 (clens_snd _ _) sl /\ no_lookahead_on_precond (p1 `nondep_then` p2) sl sl'))
(ensures (gaccessor_snd' p1 p2 sl == gaccessor_snd' p1 p2 sl'))
= nondep_then_eq p1 p2 sl;
nondep_then_eq p1 p2 sl' ;
parse_strong_prefix (p1 `nondep_then` p2) sl sl';
parse_injective p1 sl sl' ;
parse_strong_prefix p1 sl sl'
[@"opaque_to_smt"]
let gaccessor_snd
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (gaccessor (p1 `nondep_then` p2) p2 (clens_snd _ _))
= Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_injective p1 p2 x));
Classical.forall_intro_2 (fun x -> Classical.move_requires (gaccessor_snd_no_lookahead p1 p2 x));
gaccessor_prop_equiv (p1 `nondep_then` p2) p2 (clens_snd _ _) (gaccessor_snd' p1 p2);
gaccessor_snd' p1 p2
let gaccessor_snd_eq
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(input: bytes)
: Lemma
(gaccessor_snd p1 p2 input == gaccessor_snd' p1 p2 input)
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2 input )
let gaccessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(g: gaccessor p0 (p1 `nondep_then` p2) cl)
: Tot (gaccessor p0 p2 (cl `clens_compose` clens_snd _ _))
= g `gaccessor_compose` gaccessor_snd _ _
(*
let clens_fst_snd_disjoint
(t1 t2: Type)
: Lemma
(clens_disjoint (clens_fst t1 t2) (clens_snd t1 t2))
= clens_disjoint_l_intro (clens_fst t1 t2) (clens_snd t1 t2) (fun x1 x2 -> ());
clens_disjoint_l_intro (clens_snd t1 t2) (clens_fst t1 t2) (fun x1 x2 -> ())
*)
(*
abstract
let gaccessor_fst_snd_disjoint
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash (k1.parser_kind_subkind == Some ParserStrong))
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Lemma
(gaccessors_disjoint (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2))
= // clens_fst_snd_disjoint t1 t2;
gaccessors_disjoint_intro (gaccessor_fst p1 sq p2) (gaccessor_snd p1 p2) (* *) (fun x -> ())
*)
inline_for_extraction
let accessor_fst
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(sq: squash unit)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_fst p1 sq p2))
= reveal_opaque (`%gaccessor_fst) (gaccessor_fst p1 sq p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = slice_access_eq h (gaccessor_fst p1 sq p2) input pos in
pos
inline_for_extraction
let accessor_fst_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k' : parser_kind)
(#t' : Type)
(#p': parser k' t')
(#cl: clens t1 t')
(#g: gaccessor p1 p' cl)
(a: accessor g)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(u: squash unit)
: Tot (accessor (gaccessor_fst_then g p2 u))
= accessor_compose (accessor_fst p1 u p2) a u
inline_for_extraction
let accessor_then_fst
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
: Tot (accessor (gaccessor_then_fst g))
= accessor_compose a (accessor_fst p1 () p2) ()
inline_for_extraction
let accessor_snd
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
: Tot (accessor (gaccessor_snd p1 p2))
= reveal_opaque (`%gaccessor_snd) (gaccessor_snd p1 p2);
fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_nondep_then h p1 p2 input pos in
let res = j1 input pos in
[@inline_let] let _ =
slice_access_eq h (gaccessor_snd p1 p2) input pos;
valid_facts p1 h input pos
in
res
inline_for_extraction
let accessor_then_snd
(#k0: parser_kind)
(#t0: Type)
(#p0: parser k0 t0)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t0 (t1 & t2))
(#g: gaccessor p0 (p1 `nondep_then` p2) cl)
(a: accessor g)
(j1: jumper p1)
: Tot (accessor (gaccessor_then_snd g))
= accessor_compose a (accessor_snd j1 p2) ()
inline_for_extraction
let make_total_constant_size_reader
(sz: nat)
(sz' : U32.t { U32.v sz' == sz } )
(#t: Type)
(f: ((s: bytes {Seq.length s == sz}) -> GTot (t)))
(u: unit {
make_total_constant_size_parser_precond sz t f
})
(f' : ((#rrel: _) -> (#rel: _) -> (s: B.mbuffer byte rrel rel) -> (pos: U32.t) -> HST.Stack t
(requires (fun h -> B.live h s /\ U32.v pos + sz <= B.length s))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (Seq.slice (B.as_seq h s) (U32.v pos) (U32.v pos + sz))
))))
: Tot (leaf_reader (make_total_constant_size_parser sz t f))
= fun #rrel #rel sl pos ->
let h = HST.get () in
[@inline_let] let _ = valid_facts (make_total_constant_size_parser sz t f) h sl pos in
f' sl.base pos
let valid_filter
(#rrel #rel: _)
(h: HS.mem)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(f: (t -> GTot bool))
(input: slice rrel rel)
(pos: U32.t)
: Lemma
(
(valid (parse_filter p f) h input pos \/ (valid p h input pos /\ f (contents p h input pos))) ==> (
valid p h input pos /\
f (contents p h input pos) == true /\
valid_content_pos (parse_filter p f) h input pos (contents p h input pos) (get_valid_pos p h input pos)
))
= valid_facts (parse_filter p f) h input pos;
valid_facts p h input pos;
if U32.v pos <= U32.v input.len
then parse_filter_eq p f (bytes_of_slice_from h input pos)
inline_for_extraction
let validate_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then res
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then validator_error_generic
else res
inline_for_extraction
let validate_filter_with_error_code
(#k: parser_kind)
(#t: Type0)
(#p: parser k t)
(v32: validator p)
(p32: leaf_reader p)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input (uint64_to_uint32 pos) in
let res = v32 input pos in
if is_error res
then maybe_set_validator_error_pos_and_code res pos c
else
let va = p32 input (uint64_to_uint32 pos) in
if not (f' va)
then set_validator_error_pos_and_code validator_error_generic pos c
else res
inline_for_extraction
let validate_filter_ret
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then validator_error_generic
else pos
inline_for_extraction
let validate_filter_ret_with_error_code
(#t: Type0)
(r: t)
(f: (t -> GTot bool))
(f' : ((x: t) -> Tot (y: bool { y == f x } )))
(c: error_code)
: Tot (validator (parse_filter (parse_ret r) f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h (parse_ret r) f input (uint64_to_uint32 pos) in
[@inline_let] let _ = valid_facts (parse_ret r) h input (uint64_to_uint32 pos) in
if not (f' r)
then set_validator_error_pos_and_code validator_error_generic pos c
else pos
inline_for_extraction
let jump_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> GTot bool))
: Tot (jumper (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
j input pos
inline_for_extraction
let read_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(p32: leaf_reader p)
(f: (t -> GTot bool))
: Tot (leaf_reader (parse_filter p f))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
(p32 input pos <: (res: t { f res == true } )) // FIXME: WHY WHY WHY do we need this coercion?
inline_for_extraction
let write_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_strong s)
(f: (t -> GTot bool))
: Tot (leaf_writer_strong (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let write_filter_weak
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: leaf_writer_weak s)
(f: (t -> GTot bool))
: Tot (leaf_writer_weak (serialize_filter s f))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialized_length_eq s x in
[@inline_let] let _ = serialized_length_eq (serialize_filter s f) x in
let res = s32 x input pos in
let h = HST.get () in
[@inline_let] let _ = valid_filter h p f input pos in
res
inline_for_extraction
let serialize32_filter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p)
(s32: serializer32 s)
(f: (t -> GTot bool))
: Tot (serializer32 (serialize_filter s f))
= fun x #rrel #rel input pos ->
s32 x input pos
inline_for_extraction
let read_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
let res = p1' input pos in
f2' res <: t2 // FIXME: WHY WHY WHY this coercion AND the separate let binding?
inline_for_extraction
let read_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_synth p1 f2 (fun x -> f2 x) p1' u
inline_for_extraction
let read_inline_synth
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> GTot t2)
(f2': (x: t1) -> Tot (y: t2 { y == f2 x } ))
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
[@inline_let] let f2'' (x: t1) : HST.Stack t2 (requires (fun _ -> True)) (ensures (fun h y h' -> h == h' /\ y == f2 x)) = f2' x in // FIXME: WHY WHY WHY do I need this stateful function here? why can't I directly use f2' ?
f2'' (p1' input pos)
inline_for_extraction
let read_inline_synth'
(#k: parser_kind)
(#t1: Type)
(#t2: Type)
(p1: parser k t1)
(f2: t1 -> Tot t2)
(p1' : leaf_reader p1)
(u: unit {
synth_injective f2
})
: Tot (leaf_reader (parse_synth p1 f2))
= read_inline_synth p1 f2 (fun x -> f2 x) p1' ()
inline_for_extraction
let write_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_strong s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_strong (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let write_synth_weak
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : leaf_writer_weak s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (leaf_writer_weak (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ = serialize_synth_eq p1 f2 s1 g1 () x in
[@inline_let] let _ = serialized_length_eq (serialize_synth p1 f2 s1 g1 ()) x in
[@inline_let] let _ = serialized_length_eq s1 (g1 x) in
let pos' = s1' (g1' x) input pos in
let h = HST.get () in
[@inline_let] let _ = valid_synth h p1 f2 input pos in
pos'
inline_for_extraction
let serialize32_synth
(#k: parser_kind)
(#t1: Type)
(#p1: parser k t1)
(#s1: serializer p1)
(s1' : serializer32 s1)
(#t2: Type)
(f2: t1 -> GTot t2)
(g1: t2 -> GTot t1)
(g1' : (x2: t2) -> Tot (x1: t1 { x1 == g1 x2 } ))
(u: squash (synth_injective f2 /\ synth_inverse f2 g1))
: Tot (serializer32 (serialize_synth p1 f2 s1 g1 ()))
= fun x #rrel #rel input pos ->
[@inline_let] let _ =
serialize_synth_eq p1 f2 s1 g1 () x
in
s1' (g1' x) input pos
(* Special case for vldata and maybe also sum types *)
inline_for_extraction
let validate_filter_and_then
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(v1: validator p1)
(p1': leaf_reader p1)
(f: (t1 -> GTot bool))
(f' : ((x: t1) -> Tot (y: bool { y == f x } )))
(#k2: parser_kind)
(#t2: Type)
(#p2: ((x: t1 { f x == true} ) -> parser k2 t2))
(v2: ((x1: t1 { f x1 == true } ) -> validator (p2 x1)))
(u: unit {
and_then_cases_injective p2
})
: Tot (validator (parse_filter p1 f `and_then` p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ =
let sinput = bytes_of_slice_from h input (uint64_to_uint32 pos) in
valid_facts (parse_filter p1 f `and_then` p2) h input (uint64_to_uint32 pos);
and_then_eq (parse_filter p1 f) p2 sinput;
parse_filter_eq p1 f sinput;
valid_facts p1 h input (uint64_to_uint32 pos)
in
let res = v1 input pos in
if is_error res
then res
else
let va = p1' input (uint64_to_uint32 pos) in
if f' va
then
[@inline_let]
let _ = valid_facts (p2 va) h input (uint64_to_uint32 res) in
v2 va input res
else validator_error_generic
inline_for_extraction
let validate_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: validator p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (validator (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p2 h input (uint64_to_uint32 pos) in
v2 input pos
inline_for_extraction
let jump_weaken
(k1: parser_kind)
(#k2: parser_kind)
(#t: Type)
(#p2: parser k2 t)
(v2: jumper p2)
(sq: squash (k1 `is_weaker_than` k2))
: Tot (jumper (weaken k1 p2))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (weaken k1 p2) h input pos in
[@inline_let]
let _ = valid_facts p2 h input pos in
v2 input pos
inline_for_extraction
let validate_strengthen
(k2: parser_kind)
(#k1: parser_kind)
(#t: Type)
(#p1: parser k1 t)
(v1: validator p1)
(sq: squash (parser_kind_prop k2 p1))
: Tot (validator (strengthen k2 p1))
= fun #rrel #rel input pos ->
let h = HST.get () in
[@inline_let]
let _ = valid_facts (strengthen k2 p1) h input (uint64_to_uint32 pos) in
[@inline_let]
let _ = valid_facts p1 h input (uint64_to_uint32 pos) in
v1 input pos
inline_for_extraction
let validate_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (validator (p k))))
(k: kt2)
: Tot (validator (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
inline_for_extraction
let jump_compose_context
(#pk: parser_kind)
(#kt1 #kt2: Type)
(f: (kt2 -> Tot kt1))
(t: (kt1 -> Tot Type))
(p: ((k: kt1) -> Tot (parser pk (t k))))
(v: ((k: kt1) -> Tot (jumper (p k))))
(k: kt2)
: Tot (jumper (p (f k)))
= fun #rrel #rel input pos -> v (f k) input pos
let clens_tagged_union_tag
(#tag_t: Type)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
: Tot (clens data_t tag_t)
= {
clens_cond = (fun _ -> True);
clens_get = tag_of_data;
} | {
"checked_file": "/",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowStar.Failure.fsti.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Spec.Combinators.fsti.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt64.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Combinators.fsti"
} | [
{
"abbrev": true,
"full_module": "FStar.Int.Cast",
"short_module": "Cast"
},
{
"abbrev": true,
"full_module": "FStar.UInt64",
"short_module": "U64"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B0"
},
{
"abbrev": true,
"full_module": "LowStar.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"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
}
] | {
"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"
} | false |
pt: LowParse.Spec.Base.parser kt tag_t ->
tag_of_data: (_: data_t -> Prims.GTot tag_t) ->
p: (t: tag_t -> LowParse.Spec.Base.parser k (LowParse.Spec.Base.refine_with_tag tag_of_data t))
-> LowParse.Low.Base.Spec.gaccessor' (LowParse.Spec.Combinators.parse_tagged_union pt
tag_of_data
p)
pt
(LowParse.Low.Combinators.clens_tagged_union_tag tag_of_data) | Prims.Tot | [
"total"
] | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.refine_with_tag",
"LowParse.Bytes.bytes",
"Prims.unit",
"LowParse.Spec.Combinators.parse_tagged_union_eq",
"Prims.nat",
"LowParse.Low.Base.Spec.gaccessor'",
"LowParse.Spec.Combinators.and_then_kind",
"LowParse.Spec.Combinators.parse_tagged_union",
"LowParse.Low.Combinators.clens_tagged_union_tag"
] | [] | false | false | false | false | false | let gaccessor_tagged_union_tag'
(#kt: parser_kind)
(#tag_t: Type)
(pt: parser kt tag_t)
(#data_t: Type)
(tag_of_data: (data_t -> GTot tag_t))
(#k: parser_kind)
(p: (t: tag_t -> Tot (parser k (refine_with_tag tag_of_data t))))
: Tot (gaccessor' (parse_tagged_union pt tag_of_data p) pt (clens_tagged_union_tag tag_of_data)) =
| fun input ->
parse_tagged_union_eq pt tag_of_data p input;
0 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.