effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Pure | val seq_find_aux (#a: Type) (f: (a -> Tot bool)) (l: seq a) (ctr: nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i: nat{i < Seq.length l /\ i >= ctr}). not (f (Seq.index l i))))
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
) | [
{
"abbrev": true,
"full_module": "FStar.Seq.Base",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "FStar.Seq.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Seq",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)}
found i /\ x == Seq.index l i)))
= match ctr with
| 0 -> None
| _ -> let i = ctr - 1 in
if f (Seq.index l i)
then (
cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i | val seq_find_aux (#a: Type) (f: (a -> Tot bool)) (l: seq a) (ctr: nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i: nat{i < Seq.length l /\ i >= ctr}). not (f (Seq.index l i))))
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
)
let rec seq_find_aux (#a: Type) (f: (a -> Tot bool)) (l: seq a) (ctr: nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i: nat{i < Seq.length l /\ i >= ctr}). not (f (Seq.index l i))))
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
) = | false | null | false | match ctr with
| 0 -> None
| _ ->
let i = ctr - 1 in
if f (Seq.index l i)
then
(cut (found i);
Some (Seq.index l i))
else seq_find_aux f l i | {
"checked_file": "FStar.Seq.Properties.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Seq.Base.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.Properties.fst.checked",
"FStar.List.Tot.Base.fst.checked",
"FStar.List.Tot.fst.checked"
],
"interface_file": false,
"source_file": "FStar.Seq.Properties.fsti"
} | [] | [
"Prims.bool",
"FStar.Seq.Base.seq",
"Prims.nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.None",
"Prims.int",
"FStar.Seq.Base.index",
"FStar.Pervasives.Native.Some",
"Prims.unit",
"Prims.cut",
"FStar.Seq.Properties.found",
"FStar.Seq.Properties.seq_find_aux",
"FStar.Pervasives.Native.option",
"Prims.op_Subtraction",
"Prims.l_Forall",
"Prims.l_and",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"Prims.op_Negation",
"Prims.l_Exists",
"Prims.eq2"
] | [] | (*
Copyright 2008-2014 Nikhil Swamy and Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Seq.Properties
open FStar.Seq.Base
module Seq = FStar.Seq.Base
let lseq (a: Type) (l: nat) : Tot Type =
s: Seq.seq a { Seq.length s == l }
let indexable (#a:Type) (s:Seq.seq a) (j:int) = 0 <= j /\ j < Seq.length s
val lemma_append_inj_l: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s1}
-> Lemma (index s1 i == index t1 i)
val lemma_append_inj_r: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a{length s1 = length t1 /\ length s2 = length t2 /\ equal (append s1 s2) (append t1 t2)} -> i:nat{i < length s2}
-> Lemma (ensures (index s2 i == index t2 i))
val lemma_append_len_disj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {(length s1 = length t1 \/ length s2 = length t2) /\ (equal (append s1 s2) (append t1 t2))}
-> Lemma (ensures (length s1 = length t1 /\ length s2 = length t2))
val lemma_append_inj: #a:Type -> s1:seq a -> s2:seq a -> t1:seq a -> t2:seq a {length s1 = length t1 \/ length s2 = length t2}
-> Lemma (requires (equal (append s1 s2) (append t1 t2)))
(ensures (equal s1 t1 /\ equal s2 t2))
let head (#a:Type) (s:seq a{length s > 0}) : Tot a = index s 0
let tail (#a:Type) (s:seq a{length s > 0}) : Tot (seq a) = slice s 1 (length s)
val lemma_head_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(head (append s1 s2) == head s1)
val lemma_tail_append: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(tail (append s1 s2) == append (tail s1) s2)
let last (#a:Type) (s:seq a{length s > 0}) : Tot a = index s (length s - 1)
let cons (#a:Type) (x:a) (s:seq a) : Tot (seq a) = append (create 1 x) s
val lemma_cons_inj: #a:Type -> v1:a -> v2:a -> s1:seq a -> s2:seq a
-> Lemma (requires (equal (cons v1 s1) (cons v2 s2)))
(ensures (v1 == v2 /\ equal s1 s2))
let split (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)}) : Tot (seq a * seq a)
= slice s 0 i, slice s i (length s)
val lemma_split : #a:Type -> s:seq a -> i:nat{(0 <= i /\ i <= length s)} -> Lemma
(ensures (append (fst (split s i)) (snd (split s i)) == s))
let split_eq (#a:Type) (s:seq a) (i:nat{(0 <= i /\ i <= length s)})
: Pure
(seq a * seq a)
(requires True)
(ensures (fun x -> (append (fst x) (snd x) == s)))
= let x = split s i in
lemma_split s i;
x
let rec count (#a:eqtype) (x:a) (s:seq a) : Tot nat (decreases (length s))
= if length s = 0 then 0
else if head s = x
then 1 + count x (tail s)
else count x (tail s)
let mem (#a:eqtype) (x:a) (l:seq a) : Tot bool = count x l > 0
val mem_index (#a:eqtype) (x:a) (s:seq a)
: Lemma (requires (mem x s))
(ensures (exists i. index s i == x))
(* index_mem:
A utility function that finds the first index of
`x` in `s`, given that we know the `x` is actually contained in `s` *)
let rec index_mem (#a:eqtype) (x:a) (s:seq a)
: Pure nat
(requires (mem x s))
(ensures (fun i -> i < length s /\ index s i == x))
(decreases (length s))
= if head s = x then 0
else 1 + index_mem x (tail s)
let swap (#a:Type) (s:seq a) (i:nat{i<length s}) (j:nat{j<length s}) : Tot (seq a)
= upd (upd s j (index s i)) i (index s j)
val lemma_slice_append: #a:Type -> s1:seq a{length s1 >= 1} -> s2:seq a -> Lemma
(ensures (equal (append s1 s2) (append (slice s1 0 1) (append (slice s1 1 (length s1)) s2))))
val lemma_slice_first_in_append: #a:Type -> s1:seq a -> s2:seq a -> i:nat{i <= length s1} -> Lemma
(ensures (equal (slice (append s1 s2) i (length (append s1 s2))) (append (slice s1 i (length s1)) s2)))
val slice_upd: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < length s} -> v:a -> Lemma
(requires k < i \/ j <= k)
(ensures slice (upd s k v) i j == slice s i j)
[SMTPat (slice (upd s k v) i j)]
val upd_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i <= j /\ j <= length s}
-> k:nat{k < j - i} -> v:a -> Lemma
(requires i + k < j)
(ensures upd (slice s i j) k v == slice (upd s (i + k) v) i j)
[SMTPat (upd (slice s i j) k v)]
// TODO: should be renamed cons_head_append, or something like that (because it is NOT related to (append (cons _ _) _))
val lemma_append_cons: #a:Type -> s1:seq a{length s1 > 0} -> s2:seq a -> Lemma
(requires True)
(ensures (equal (append s1 s2) (cons (head s1) (append (tail s1) s2))))
val lemma_tl: #a:Type -> hd:a -> tl:seq a -> Lemma
(ensures (equal (tail (cons hd tl)) tl))
let rec sorted (#a:Type) (f:a -> a -> Tot bool) (s:seq a)
: Tot bool (decreases (length s))
= if length s <= 1
then true
else let hd = head s in
f hd (index s 1) && sorted f (tail s)
val sorted_feq (#a:Type)
(f g : (a -> a -> Tot bool))
(s:seq a{forall x y. f x y == g x y})
: Lemma (ensures (sorted f s <==> sorted g s))
val lemma_append_count: #a:eqtype -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (forall x. count x (append lo hi) = (count x lo + count x hi)))
val lemma_append_count_aux: #a:eqtype -> x:a -> lo:seq a -> hi:seq a -> Lemma
(requires True)
(ensures (count x (append lo hi) = (count x lo + count x hi)))
val lemma_mem_inversion: #a:eqtype -> s:seq a{length s > 0} -> Lemma
(ensures (forall x. mem x s = (x=head s || mem x (tail s))))
val lemma_mem_count: #a:eqtype -> s:seq a -> f:(a -> Tot bool) -> Lemma
(requires (forall (i:nat{i<length s}). f (index s i)))
(ensures (forall (x:a). mem x s ==> f x))
val lemma_count_slice: #a:eqtype -> s:seq a -> i:nat{i<=length s} -> Lemma
(requires True)
(ensures (forall x. count x s = count x (slice s 0 i) + count x (slice s i (length s))))
type total_order (a:eqtype) (f: (a -> a -> Tot bool)) =
(forall a. f a a) (* reflexivity *)
/\ (forall a1 a2. (f a1 a2 /\ a1<>a2) <==> not (f a2 a1)) (* anti-symmetry *)
/\ (forall a1 a2 a3. f a1 a2 /\ f a2 a3 ==> f a1 a3) (* transitivity *)
type tot_ord (a:eqtype) = f:(a -> a -> Tot bool){total_order a f}
val sorted_concat_lemma: #a:eqtype
-> f:(a -> a -> Tot bool){total_order a f}
-> lo:seq a{sorted f lo}
-> pivot:a
-> hi:seq a{sorted f hi}
-> Lemma (requires (forall y. (mem y lo ==> f y pivot)
/\ (mem y hi ==> f pivot y)))
(ensures (sorted f (append lo (cons pivot hi))))
val split_5 : #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j < length s} -> Pure (seq (seq a))
(requires True)
(ensures (fun x ->
(length x = 5
/\ equal s (append (index x 0) (append (index x 1) (append (index x 2) (append (index x 3) (index x 4)))))
/\ equal (index x 0) (slice s 0 i)
/\ equal (index x 1) (slice s i (i+1))
/\ equal (index x 2) (slice s (i+1) j)
/\ equal (index x 3) (slice s j (j + 1))
/\ equal (index x 4) (slice s (j + 1) (length s)))))
val lemma_swap_permutes_aux_frag_eq: #a:Type -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s}
-> i':nat -> j':nat{i' <= j' /\ j'<=length s /\
(j < i' //high slice
\/ j' <= i //low slice
\/ (i < i' /\ j' <= j)) //mid slice
}
-> Lemma (ensures (slice s i' j' == slice (swap s i j) i' j'
/\ slice s i (i + 1) == slice (swap s i j) j (j + 1)
/\ slice s j (j + 1) == slice (swap s i j) i (i + 1)))
val lemma_swap_permutes_aux: #a:eqtype -> s:seq a -> i:nat{i<length s} -> j:nat{i <= j && j<length s} -> x:a -> Lemma
(requires True)
(ensures (count x s = count x (swap s i j)))
type permutation (a:eqtype) (s1:seq a) (s2:seq a) =
(forall i. count i s1 = count i s2)
val append_permutations: #a:eqtype -> s1:seq a -> s2:seq a -> s1':seq a -> s2':seq a -> Lemma
(requires permutation a s1 s1' /\ permutation a s2 s2')
(ensures permutation a (append s1 s2) (append s1' s2'))
val lemma_swap_permutes (#a:eqtype) (s:seq a) (i:nat{i<length s}) (j:nat{i <= j && j<length s})
: Lemma (permutation a s (swap s i j))
(* perm_len:
A lemma that shows that two sequences that are permutations
of each other also have the same length
*)
val perm_len (#a:eqtype) (s1 s2: seq a)
: Lemma (requires (permutation a s1 s2))
(ensures (length s1 == length s2))
val cons_perm: #a:eqtype -> tl:seq a -> s:seq a{length s > 0} ->
Lemma (requires (permutation a tl (tail s)))
(ensures (permutation a (cons (head s) tl) s))
val lemma_mem_append : #a:eqtype -> s1:seq a -> s2:seq a
-> Lemma (ensures (forall x. mem x (append s1 s2) <==> (mem x s1 || mem x s2)))
val lemma_slice_cons: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s i || mem x (slice s (i + 1) j))))
val lemma_slice_snoc: #a:eqtype -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma (ensures (forall x. mem x (slice s i j) <==> (x = index s (j - 1) || mem x (slice s i (j - 1)))))
val lemma_ordering_lo_snoc: #a:eqtype -> f:tot_ord a -> s:seq a -> i:nat -> j:nat{i <= j && j < length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s i j) ==> f y pv) /\ f (index s j) pv))
(ensures ((forall y. mem y (slice s i (j + 1)) ==> f y pv)))
val lemma_ordering_hi_cons: #a:eqtype -> f:tot_ord a -> s:seq a -> back:nat -> len:nat{back < len && len <= length s} -> pv:a
-> Lemma (requires ((forall y. mem y (slice s (back + 1) len) ==> f pv y) /\ f pv (index s back)))
(ensures ((forall y. mem y (slice s back len) ==> f pv y)))
val swap_frame_lo : #a:Type -> s:seq a -> lo:nat -> i:nat{lo <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i == slice (swap s i j) lo i))
val swap_frame_lo' : #a:Type -> s:seq a -> lo:nat -> i':nat {lo <= i'} -> i:nat{i' <= i} -> j:nat{i <= j && j < length s}
-> Lemma (ensures (slice s lo i' == slice (swap s i j) lo i'))
val swap_frame_hi : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j} -> k:nat{j < k} -> hi:nat{k <= hi /\ hi <= length s}
-> Lemma (ensures (slice s k hi == slice (swap s i j) k hi))
val lemma_swap_slice_commute : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (slice (swap s i j) start len == (swap (slice s start len) (i - start) (j - start))))
val lemma_swap_permutes_slice : #a:eqtype -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma (ensures (permutation a (slice s start len) (slice (swap s i j) start len)))
(* replaces the [i,j) sub-sequence of s1 with the corresponding sub-sequence of s2 *)
let splice (#a:Type) (s1:seq a) (i:nat) (s2:seq a{length s1=length s2}) (j:nat{i <= j /\ j <= (length s2)})
: Tot (seq a)
= Seq.append (slice s1 0 i) (Seq.append (slice s2 i j) (slice s1 j (length s1)))
(* replace with sub *)
let replace_subseq (#a:Type0) (s:Seq.seq a) (i:nat) (j:nat{i <= j /\ j <= length s}) (sub:Seq.seq a{length sub == j - i}) :Tot (Seq.seq a)
= Seq.append (Seq.slice s 0 i) (Seq.append sub (Seq.slice s j (Seq.length s)))
val splice_refl : #a:Type -> s:seq a -> i:nat -> j:nat{i <= j && j <= length s}
-> Lemma
(ensures (s == splice s i s j))
val lemma_swap_splice : #a:Type -> s:seq a -> start:nat -> i:nat{start <= i} -> j:nat{i <= j} -> len:nat{j < len && len <= length s}
-> Lemma
(ensures (swap s i j == splice s start (swap s i j) len))
val lemma_seq_frame_hi: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j <= m} -> n:nat{m < n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 i s1 j)))
(ensures ((slice s1 m n == slice s2 m n) /\ (index s1 m == index s2 m)))
val lemma_seq_frame_lo: #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat{i <= j} -> m:nat{j < m} -> n:nat{m <= n && n <= length s1}
-> Lemma
(requires (s1 == (splice s2 m s1 n)))
(ensures ((slice s1 i j == slice s2 i j) /\ (index s1 j == index s2 j)))
val lemma_tail_slice: #a:Type -> s:seq a -> i:nat -> j:nat{i < j && j <= length s}
-> Lemma
(requires True)
(ensures (tail (slice s i j) == slice s (i + 1) j))
[SMTPat (tail (slice s i j))]
val lemma_weaken_frame_right : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j))
(ensures (s1 == splice s2 i s1 k))
val lemma_weaken_frame_left : #a:Type -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j && j <= k && k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k))
(ensures (s1 == splice s2 i s1 k))
val lemma_trans_frame : #a:Type -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i <= j && j <= length s1}
-> Lemma
(requires ((s1 == splice s2 i s1 j) /\ s2 == splice s3 i s2 j))
(ensures (s1 == splice s3 i s1 j))
val lemma_weaken_perm_left: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 j s1 k /\ permutation a (slice s2 j k) (slice s1 j k)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_weaken_perm_right: #a:eqtype -> s1:seq a -> s2:seq a{length s1 = length s2} -> i:nat -> j:nat -> k:nat{i <= j /\ j <= k /\ k <= length s1}
-> Lemma
(requires (s1 == splice s2 i s1 j /\ permutation a (slice s2 i j) (slice s1 i j)))
(ensures (permutation a (slice s2 i k) (slice s1 i k)))
val lemma_trans_perm: #a:eqtype -> s1:seq a -> s2:seq a -> s3:seq a{length s1 = length s2 /\ length s2 = length s3} -> i:nat -> j:nat{i<=j && j <= length s1}
-> Lemma
(requires (permutation a (slice s1 i j) (slice s2 i j)
/\ permutation a (slice s2 i j) (slice s3 i j)))
(ensures (permutation a (slice s1 i j) (slice s3 i j)))
(*New additions, please review*)
let snoc (#a:Type) (s:seq a) (x:a) : Tot (seq a) = Seq.append s (Seq.create 1 x)
val lemma_cons_snoc (#a:Type) (hd:a) (s:Seq.seq a) (tl:a)
: Lemma (requires True)
(ensures (Seq.equal (cons hd (snoc s tl))
(snoc (cons hd s) tl)))
val lemma_tail_snoc: #a:Type -> s:Seq.seq a{Seq.length s > 0} -> x:a
-> Lemma (ensures (tail (snoc s x) == snoc (tail s) x))
val lemma_snoc_inj: #a:Type -> s1:seq a -> s2:seq a -> v1:a -> v2:a
-> Lemma (requires (equal (snoc s1 v1) (snoc s2 v2)))
(ensures (v1 == v2 /\ equal s1 s2))
val lemma_mem_snoc : #a:eqtype -> s:Seq.seq a -> x:a ->
Lemma (ensures (forall y. mem y (snoc s x) <==> mem y s \/ x=y))
let rec find_l (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else find_l f (tail l)
let rec ghost_find_l (#a:Type) (f:a -> GTot bool) (l:seq a)
: GTot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else if f (head l) then Some (head l)
else ghost_find_l f (tail l)
val find_append_some: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (Some? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_append_none: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s1)))
(ensures (find_l f (append s1 s2) == find_l f s2))
val find_append_none_s2: #a:Type -> s1:seq a -> s2:seq a -> f:(a -> Tot bool) -> Lemma
(requires (None? (find_l f s2)))
(ensures (find_l f (append s1 s2) == find_l f s1))
val find_snoc: #a:Type -> s:Seq.seq a -> x:a -> f:(a -> Tot bool)
-> Lemma (ensures (let res = find_l f (snoc s x) in
match res with
| None -> find_l f s == None /\ not (f x)
| Some y -> res == find_l f s \/ (f x /\ x==y)))
let un_snoc (#a:Type) (s:seq a{length s <> 0}) : Tot (r:(seq a * a){s == snoc (fst r) (snd r)}) =
let s', a = split s (length s - 1) in
assert (Seq.equal (snoc s' (Seq.index a 0)) s);
s', Seq.index a 0
val un_snoc_snoc (#a:Type) (s:seq a) (x:a) : Lemma (un_snoc (snoc s x) == (s, x))
let rec find_r (#a:Type) (f:a -> Tot bool) (l:seq a)
: Tot (o:option a{Some? o ==> f (Some?.v o)})
(decreases (Seq.length l))
= if Seq.length l = 0 then None
else let prefix, last = un_snoc l in
if f last then Some last
else find_r f prefix
type found (i:nat) = True
let rec seq_find_aux (#a:Type) (f:a -> Tot bool) (l:seq a) (ctr:nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i:nat{ i < Seq.length l /\ i >= ctr}).
not (f (Seq.index l i) )))
(ensures (function
| None -> forall (i:nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x -> f x /\ (exists (i:nat{i < Seq.length l}). {:pattern (found i)} | false | false | FStar.Seq.Properties.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val seq_find_aux (#a: Type) (f: (a -> Tot bool)) (l: seq a) (ctr: nat{ctr <= Seq.length l})
: Pure (option a)
(requires (forall (i: nat{i < Seq.length l /\ i >= ctr}). not (f (Seq.index l i))))
(ensures
(function
| None -> forall (i: nat{i < Seq.length l}). not (f (Seq.index l i))
| Some x ->
f x /\
(exists (i: nat{i < Seq.length l}). {:pattern (found i)} found i /\ x == Seq.index l i))
) | [
"recursion"
] | FStar.Seq.Properties.seq_find_aux | {
"file_name": "ulib/FStar.Seq.Properties.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | f: (_: a -> Prims.bool) -> l: FStar.Seq.Base.seq a -> ctr: Prims.nat{ctr <= FStar.Seq.Base.length l}
-> Prims.Pure (FStar.Pervasives.Native.option a) | {
"end_col": 25,
"end_line": 399,
"start_col": 2,
"start_line": 392
} |
Prims.GTot | val valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos)) | val valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0 = | false | null | false | U32.v pos <= U32.v s.len /\ live_slice h s /\ Some? (parse p (bytes_of_slice_from h s pos)) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"sometrivial"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Slice.live_slice",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Spec.Base.parse"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0 | [] | LowParse.Low.Base.Spec.valid' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> Prims.GTot Type0 | {
"end_col": 47,
"end_line": 23,
"start_col": 2,
"start_line": 21
} |
Prims.Tot | val clens_id (t: Type) : Tot (clens t t) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
} | val clens_id (t: Type) : Tot (clens t t)
let clens_id (t: Type) : Tot (clens t t) = | false | null | false | { clens_cond = (fun _ -> True); clens_get = (fun x -> x) } | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Low.Base.Spec.Mkclens",
"Prims.l_True",
"LowParse.Low.Base.Spec.clens"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
} | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_id (t: Type) : Tot (clens t t) | [] | LowParse.Low.Base.Spec.clens_id | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Type -> LowParse.Low.Base.Spec.clens t t | {
"end_col": 27,
"end_line": 956,
"start_col": 2,
"start_line": 955
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos' | let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
= | false | null | false | valid p h sl pos /\ U32.v pos + content_length p h sl pos == U32.v pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.content_length",
"Prims.logical"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_pos : p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.logical | [] | LowParse.Low.Base.Spec.valid_pos | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.logical | {
"end_col": 53,
"end_line": 260,
"start_col": 2,
"start_line": 259
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl') | let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= | false | null | false | (forall (sl: bytes) (sl': bytes). {:pattern (f sl); (f sl')}
(gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==>
f sl == f sl') | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor'",
"Prims.l_Forall",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Base.injective_precond",
"Prims.eq2",
"Prims.nat",
"Prims.logical"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_injective : f: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.logical | [] | LowParse.Low.Base.Spec.gaccessor_injective | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.logical | {
"end_col": 163,
"end_line": 1281,
"start_col": 2,
"start_line": 1281
} |
|
Prims.GTot | val clens_compose_cond (#t1 #t2: Type) (l12: clens t1 t2) (clens_cond2: (t2 -> GTot Type0)) (x1: t1)
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1) | val clens_compose_cond (#t1 #t2: Type) (l12: clens t1 t2) (clens_cond2: (t2 -> GTot Type0)) (x1: t1)
: GTot Type0
let clens_compose_cond (#t1 #t2: Type) (l12: clens t1 t2) (clens_cond2: (t2 -> GTot Type0)) (x1: t1)
: GTot Type0 = | false | null | false | l12.clens_cond x1 /\ clens_cond2 (l12.clens_get x1) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"sometrivial"
] | [
"LowParse.Low.Base.Spec.clens",
"Prims.l_and",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_compose_cond (#t1 #t2: Type) (l12: clens t1 t2) (clens_cond2: (t2 -> GTot Type0)) (x1: t1)
: GTot Type0 | [] | LowParse.Low.Base.Spec.clens_compose_cond | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l12: LowParse.Low.Base.Spec.clens t1 t2 -> clens_cond2: (_: t2 -> Prims.GTot Type0) -> x1: t1
-> Prims.GTot Type0 | {
"end_col": 32,
"end_line": 1109,
"start_col": 2,
"start_line": 1108
} |
Prims.GTot | val gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res) | val gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 = | false | null | false | res <= Seq.length sl /\ (gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Bytes.bytes",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.l_imp",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Low.Base.Spec.gaccessor_post"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0 | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 | [] | LowParse.Low.Base.Spec.gaccessor_post' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
cl: LowParse.Low.Base.Spec.clens t1 t2 ->
sl: LowParse.Bytes.bytes ->
res: Prims.nat
-> Prims.GTot Type0 | {
"end_col": 66,
"end_line": 1224,
"start_col": 4,
"start_line": 1223
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl')) | let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= | false | null | false | (k1.parser_kind_subkind == Some ParserStrong ==>
(forall (sl: bytes) (sl': bytes). {:pattern (f sl); (f sl')}
(gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==>
f sl == f sl')) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor'",
"Prims.l_imp",
"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.l_Forall",
"LowParse.Bytes.bytes",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_pre",
"LowParse.Spec.Base.no_lookahead_on_precond",
"Prims.nat",
"Prims.logical"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_no_lookahead : f: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.logical | [] | LowParse.Low.Base.Spec.gaccessor_no_lookahead | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.logical | {
"end_col": 219,
"end_line": 1251,
"start_col": 2,
"start_line": 1251
} |
|
Prims.Tot | val get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl | val get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2) = | false | null | false | cl | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2) | [] | LowParse.Low.Base.Spec.get_gaccessor_clens | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | g: LowParse.Low.Base.Spec.gaccessor p1 p2 cl -> LowParse.Low.Base.Spec.clens t1 t2 | {
"end_col": 4,
"end_line": 1340,
"start_col": 2,
"start_line": 1340
} |
Prims.GTot | val gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False | val gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0 = | false | null | false | match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.l_False"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0 | [] | LowParse.Low.Base.Spec.gaccessor_pre | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
cl: LowParse.Low.Base.Spec.clens t1 t2 ->
sl: LowParse.Bytes.bytes
-> Prims.GTot Type0 | {
"end_col": 14,
"end_line": 1185,
"start_col": 2,
"start_line": 1183
} |
Prims.GTot | val gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f | val gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0 = | false | null | false | gaccessor_no_lookahead f /\ gaccessor_injective f | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor'",
"Prims.l_and",
"LowParse.Low.Base.Spec.gaccessor_no_lookahead",
"LowParse.Low.Base.Spec.gaccessor_injective"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0 | [] | LowParse.Low.Base.Spec.gaccessor_prop' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | f: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl -> Prims.GTot Type0 | {
"end_col": 51,
"end_line": 1293,
"start_col": 2,
"start_line": 1293
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x | let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= | false | null | false | valid p h sl pos /\ contents p h sl pos == x | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents",
"Prims.logical"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_content : p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
x: t
-> Prims.logical | [] | LowParse.Low.Base.Spec.valid_content | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
x: t
-> Prims.logical | {
"end_col": 26,
"end_line": 335,
"start_col": 2,
"start_line": 334
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x | let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos': U32.t)
= | false | null | false | valid_pos p h sl pos pos' /\ valid_content p h sl pos x | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Low.Base.Spec.valid_content",
"Prims.logical"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_content_pos : p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
x: t ->
pos': FStar.UInt32.t
-> Prims.logical | [] | LowParse.Low.Base.Spec.valid_content_pos | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
x: t ->
pos': FStar.UInt32.t
-> Prims.logical | {
"end_col": 28,
"end_line": 348,
"start_col": 2,
"start_line": 347
} |
|
Prims.Ghost | val contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t (requires (valid' p h s pos)) (ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v | val contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t (requires (valid' p h s pos)) (ensures (fun _ -> True))
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t (requires (valid' p h s pos)) (ensures (fun _ -> True)) = | false | null | false | let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.consumed_length",
"LowParse.Slice.bytes_of_slice_from",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Low.Base.Spec.valid'",
"Prims.l_True"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t (requires (valid' p h s pos)) (ensures (fun _ -> True)) | [] | LowParse.Low.Base.Spec.contents' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> Prims.Ghost t | {
"end_col": 3,
"end_line": 102,
"start_col": 1,
"start_line": 101
} |
FStar.Pervasives.Lemma | val valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos /\ k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (valid_pos p h sl pos sl.len)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos | val valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos /\ k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (valid_pos p h sl pos sl.len))
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos /\ k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (valid_pos p h sl pos sl.len)) = | false | null | true | parser_kind_prop_equiv k p;
valid_facts p h sl pos | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_facts",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"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.ParserConsumesAll",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos /\ k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (valid_pos p h sl pos sl.len)) | [] | LowParse.Low.Base.Spec.valid_pos_consumes_all | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p h sl pos /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserConsumesAll)
(ensures LowParse.Low.Base.Spec.valid_pos p h sl pos (Mkslice?.len sl)) | {
"end_col": 24,
"end_line": 323,
"start_col": 2,
"start_line": 322
} |
Prims.GTot | val valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
) | val valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: GTot Type0
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: GTot Type0 = | false | null | false | U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ live_slice h s /\
(let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len') | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"sometrivial"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Slice.live_slice",
"LowParse.Spec.Base.parse",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.l_False",
"LowParse.Spec.Base.consumed_length",
"Prims.eq2",
"Prims.int",
"Prims.l_or",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.nat",
"Prims.logical",
"FStar.UInt32.sub"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: GTot Type0 | [] | LowParse.Low.Base.Spec.valid_exact' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.GTot Type0 | {
"end_col": 3,
"end_line": 411,
"start_col": 2,
"start_line": 404
} |
Prims.Ghost | val bytes_of_slice_from_to (#rrel #rel: _) (h: HS.mem) (s: slice rrel rel) (pos pos': U32.t)
: Ghost bytes
(requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos') | val bytes_of_slice_from_to (#rrel #rel: _) (h: HS.mem) (s: slice rrel rel) (pos pos': U32.t)
: Ghost bytes
(requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len))
(ensures (fun _ -> True))
let bytes_of_slice_from_to (#rrel #rel: _) (h: HS.mem) (s: slice rrel rel) (pos pos': U32.t)
: Ghost bytes
(requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len))
(ensures (fun _ -> True)) = | false | null | false | Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos') | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Seq.Base.slice",
"LowStar.Monotonic.Buffer.as_seq",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"FStar.UInt32.v",
"LowParse.Bytes.bytes",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.l_True"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val bytes_of_slice_from_to (#rrel #rel: _) (h: HS.mem) (s: slice rrel rel) (pos pos': U32.t)
: Ghost bytes
(requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len))
(ensures (fun _ -> True)) | [] | LowParse.Low.Base.Spec.bytes_of_slice_from_to | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.Ghost LowParse.Bytes.bytes | {
"end_col": 56,
"end_line": 392,
"start_col": 2,
"start_line": 392
} |
FStar.Pervasives.Lemma | val content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos))
(ensures
(let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max)))
[SMTPat (content_length p h sl pos)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos | val content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos))
(ensures
(let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max)))
[SMTPat (content_length p h sl pos)]
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos))
(ensures
(let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max)))
[SMTPat (content_length p h sl pos)] = | false | null | true | content_length_eq_gen p h sl pos | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.content_length_eq_gen",
"Prims.unit",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.l_True",
"Prims.nat",
"Prims.logical",
"LowParse.Low.Base.Spec.content_length",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
))) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h sl pos))
(ensures
(let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max)))
[SMTPat (content_length p h sl pos)] | [] | LowParse.Low.Base.Spec.content_length_post | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid p h sl pos)
(ensures
(let res = LowParse.Low.Base.Spec.content_length p h sl pos in
FStar.UInt32.v pos + res <= FStar.UInt32.v (Mkslice?.len sl) /\
Mkparser_kind'?.parser_kind_low k <= res /\
(match Mkparser_kind'?.parser_kind_high k with
| FStar.Pervasives.Native.None #_ -> Prims.l_True
| FStar.Pervasives.Native.Some #_ max -> res <= max)))
[SMTPat (LowParse.Low.Base.Spec.content_length p h sl pos)] | {
"end_col": 34,
"end_line": 216,
"start_col": 2,
"start_line": 216
} |
Prims.Tot | val clens_compose_strong
(#t1 #t2 #t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 {clens_compose_strong_pre l12 l23})
: Tot (clens t1 t3) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
} | val clens_compose_strong
(#t1 #t2 #t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 {clens_compose_strong_pre l12 l23})
: Tot (clens t1 t3)
let clens_compose_strong
(#t1 #t2 #t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 {clens_compose_strong_pre l12 l23})
: Tot (clens t1 t3) = | false | null | false | { clens_cond = l12.clens_cond; clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1)) } | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.clens_compose_strong_pre",
"LowParse.Low.Base.Spec.Mkclens",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_compose_strong
(#t1 #t2 #t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 {clens_compose_strong_pre l12 l23})
: Tot (clens t1 t3) | [] | LowParse.Low.Base.Spec.clens_compose_strong | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
l12: LowParse.Low.Base.Spec.clens t1 t2 ->
l23:
LowParse.Low.Base.Spec.clens t2 t3 {LowParse.Low.Base.Spec.clens_compose_strong_pre l12 l23}
-> LowParse.Low.Base.Spec.clens t1 t3 | {
"end_col": 59,
"end_line": 1151,
"start_col": 2,
"start_line": 1150
} |
Prims.Ghost | val contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Ghost t (requires (valid_exact' p h s pos pos')) (ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v | val contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Ghost t (requires (valid_exact' p h s pos pos')) (ensures (fun _ -> True))
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Ghost t (requires (valid_exact' p h s pos pos')) (ensures (fun _ -> True)) = | false | null | false | let Some (v, _) = parse p (bytes_of_slice_from_to h s pos pos') in
v | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.consumed_length",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Low.Base.Spec.valid_exact'",
"Prims.l_True"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos')) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Ghost t (requires (valid_exact' p h s pos pos')) (ensures (fun _ -> True)) | [] | LowParse.Low.Base.Spec.contents_exact' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> Prims.Ghost t | {
"end_col": 3,
"end_line": 489,
"start_col": 1,
"start_line": 488
} |
Prims.Tot | val clens_compose (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : Tot (clens t1 t3) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
} | val clens_compose (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : Tot (clens t1 t3)
let clens_compose (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : Tot (clens t1 t3) = | false | null | false | {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1))
} | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.Mkclens",
"LowParse.Low.Base.Spec.clens_compose_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_compose (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : Tot (clens t1 t3) | [] | LowParse.Low.Base.Spec.clens_compose | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l12: LowParse.Low.Base.Spec.clens t1 t2 -> l23: LowParse.Low.Base.Spec.clens t2 t3
-> LowParse.Low.Base.Spec.clens t1 t3 | {
"end_col": 59,
"end_line": 1120,
"start_col": 2,
"start_line": 1119
} |
FStar.Pervasives.Lemma | val valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos')) (ensures (valid_exact' p h s pos pos')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos' | val valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos')) (ensures (valid_exact' p h s pos pos'))
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos')) (ensures (valid_exact' p h s pos pos')) = | false | null | true | valid_exact_equiv p h s pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_exact'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos')) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos')) (ensures (valid_exact' p h s pos pos')) | [] | LowParse.Low.Base.Spec.valid_exact_elim | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid_exact p h s pos pos')
(ensures LowParse.Low.Base.Spec.valid_exact' p h s pos pos') | {
"end_col": 34,
"end_line": 449,
"start_col": 2,
"start_line": 449
} |
Prims.Tot | val clens_eq_intro'
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))))
(get:
(x: t -> sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)
-> Tot
(squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x)
)))
: Tot (squash (clens_eq cl1 cl2)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ()) | val clens_eq_intro'
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))))
(get:
(x: t -> sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)
-> Tot
(squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x)
)))
: Tot (squash (clens_eq cl1 cl2))
let clens_eq_intro'
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))))
(get:
(x: t -> sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)
-> Tot
(squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x)
)))
: Tot (squash (clens_eq cl1 cl2)) = | false | null | true | clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ()) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"total"
] | [
"LowParse.Low.Base.Spec.clens",
"Prims.squash",
"Prims.l_iff",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"Prims.l_and",
"Prims.eq2",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get",
"LowParse.Low.Base.Spec.clens_eq_intro",
"Prims.unit",
"LowParse.Low.Base.Spec.clens_eq"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_eq_intro'
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))))
(get:
(x: t -> sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)
-> Tot
(squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x)
)))
: Tot (squash (clens_eq cl1 cl2)) | [] | LowParse.Low.Base.Spec.clens_eq_intro' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cl1: LowParse.Low.Base.Spec.clens t t' ->
cl2: LowParse.Low.Base.Spec.clens t t' ->
cond: (x: t -> Prims.squash (Mkclens?.clens_cond cl1 x <==> Mkclens?.clens_cond cl2 x)) ->
get:
(x: t -> sq: Prims.squash (Mkclens?.clens_cond cl1 x /\ Mkclens?.clens_cond cl2 x)
-> Prims.squash (Mkclens?.clens_cond cl1 x /\ Mkclens?.clens_cond cl2 x /\
Mkclens?.clens_get cl1 x == Mkclens?.clens_get cl2 x))
-> Prims.squash (LowParse.Low.Base.Spec.clens_eq cl1 cl2) | {
"end_col": 62,
"end_line": 993,
"start_col": 2,
"start_line": 993
} |
FStar.Pervasives.Lemma | val valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
((valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==>
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos'))) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h' | val valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
((valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==>
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos')))
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
((valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==>
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos'))) = | false | null | true | Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"FStar.Classical.move_requires",
"Prims.l_and",
"LowParse.Slice.live_slice",
"LowParse.Low.Base.Spec.valid_pos",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"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.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.valid_pos_frame_strong_2",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_frame_strong_1",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
((valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==>
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos'))) | [] | LowParse.Low.Base.Spec.valid_pos_frame_strong | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl pos pos') l /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' \/
LowParse.Low.Base.Spec.valid_pos p h' sl pos pos' ==>
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' /\
LowParse.Low.Base.Spec.valid_content_pos p
h'
sl
pos
(LowParse.Low.Base.Spec.contents p h sl pos)
pos') | {
"end_col": 73,
"end_line": 786,
"start_col": 2,
"start_line": 785
} |
FStar.Pervasives.Lemma | val valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h sl pos pos'))
(ensures
(serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
() | val valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h sl pos pos'))
(ensures
(serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h sl pos pos'))
(ensures
(serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos')) = | false | null | true | valid_exact_equiv p h sl pos pos';
contents_exact_eq p h sl pos pos';
serializer_correct_implies_complete p s;
() | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.unit",
"LowParse.Spec.Base.serializer_correct_implies_complete",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.squash",
"Prims.eq2",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h sl pos pos'))
(ensures
(serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos')) | [] | LowParse.Low.Base.Spec.valid_exact_serialize | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Base.serializer p ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid_exact p h sl pos pos')
(ensures
LowParse.Spec.Base.serialize s (LowParse.Low.Base.Spec.contents_exact p h sl pos pos') ==
LowParse.Low.Base.Spec.bytes_of_slice_from_to h sl pos pos') | {
"end_col": 4,
"end_line": 535,
"start_col": 2,
"start_line": 532
} |
Prims.Ghost | val gaccessor_id' (#k: parser_kind) (#t: Type) (p: parser k t) (input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p p (clens_id _) input res)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0 | val gaccessor_id' (#k: parser_kind) (#t: Type) (p: parser k t) (input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
let gaccessor_id' (#k: parser_kind) (#t: Type) (p: parser k t) (input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p p (clens_id _) input res)) = | false | null | false | 0 | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"Prims.nat",
"Prims.l_True",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Low.Base.Spec.clens_id"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_id' (#k: parser_kind) (#t: Type) (p: parser k t) (input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p p (clens_id _) input res)) | [] | LowParse.Low.Base.Spec.gaccessor_id' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: LowParse.Spec.Base.parser k t -> input: LowParse.Bytes.bytes -> Prims.Ghost Prims.nat | {
"end_col": 3,
"end_line": 1486,
"start_col": 2,
"start_line": 1486
} |
FStar.Pervasives.Lemma | val valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos | val valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos)) = | false | null | true | valid_valid_exact p h s pos | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_valid_exact",
"Prims.unit",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_pos",
"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.squash",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos)) | [] | LowParse.Low.Base.Spec.valid_pos_valid_exact | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_pos p h s pos pos' /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h s pos pos' ==
LowParse.Low.Base.Spec.contents p h s pos) | {
"end_col": 29,
"end_line": 663,
"start_col": 2,
"start_line": 663
} |
Prims.Ghost | val gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3 | val gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res)) = | false | null | false | let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3 | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Bytes.bytes",
"Prims.op_Addition",
"Prims.nat",
"FStar.Seq.Base.seq",
"LowParse.Bytes.byte",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"Prims.l_True",
"LowParse.Low.Base.Spec.gaccessor_post'",
"LowParse.Low.Base.Spec.clens_compose"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res)) | [] | LowParse.Low.Base.Spec.gaccessor_compose' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
a12: LowParse.Low.Base.Spec.gaccessor p1 p2 cl12 ->
a23: LowParse.Low.Base.Spec.gaccessor p2 p3 cl23 ->
input: LowParse.Bytes.bytes
-> Prims.Ghost Prims.nat | {
"end_col": 13,
"end_line": 1564,
"start_col": 1,
"start_line": 1561
} |
FStar.Pervasives.Lemma | val valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures
((valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len))) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len | val valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures
((valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)))
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures
((valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len))) = | false | null | true | parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Classical.move_requires",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact'",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.contents_exact'",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"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.ParserConsumesAll",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.valid_content_pos",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures
((valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len))) | [] | LowParse.Low.Base.Spec.valid_valid_exact_consumes_all | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserConsumesAll)
(ensures
LowParse.Low.Base.Spec.valid p h s pos \/
LowParse.Low.Base.Spec.valid_exact p h s pos (Mkslice?.len s) ==>
LowParse.Low.Base.Spec.valid_exact p h s pos (Mkslice?.len s) /\
LowParse.Low.Base.Spec.valid_content_pos p
h
s
pos
(LowParse.Low.Base.Spec.contents_exact p h s pos (Mkslice?.len s))
(Mkslice?.len s)) | {
"end_col": 61,
"end_line": 622,
"start_col": 2,
"start_line": 619
} |
FStar.Pervasives.Lemma | val valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_list p h sl pos pos /\ contents_list p h sl pos pos == [])) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == []
))
= valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos | val valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_list p h sl pos pos /\ contents_list p h sl pos pos == []))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_list p h sl pos pos /\ contents_list p h sl pos pos == [])) = | false | null | true | valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.contents_list_eq",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list_equiv",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Slice.live_slice",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"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.squash",
"LowParse.Low.Base.Spec.valid_list",
"Prims.list",
"LowParse.Low.Base.Spec.contents_list",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos'
val contents_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost (list t)
(requires (valid_list p h sl pos pos'))
(ensures (fun _ -> True))
(decreases (U32.v pos' - U32.v pos))
val contents_list_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (contents_list p h sl pos pos' == (
valid_list_equiv p h sl pos pos';
if pos = pos'
then []
else
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
)))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == [] | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires
(U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_list p h sl pos pos /\ contents_list p h sl pos pos == [])) | [] | LowParse.Low.Base.Spec.valid_list_nil | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
FStar.UInt32.v pos <= FStar.UInt32.v (Mkslice?.len sl) /\ LowParse.Slice.live_slice h sl /\
Mkparser_kind'?.parser_kind_low k > 0 /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_list p h sl pos pos /\
LowParse.Low.Base.Spec.contents_list p h sl pos pos == []) | {
"end_col": 33,
"end_line": 1955,
"start_col": 2,
"start_line": 1954
} |
FStar.Pervasives.Lemma | val valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid_pos p h sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos' | val valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid_pos p h sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos'))
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid_pos p h sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos')) = | false | null | true | valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"LowParse.Low.Base.Spec.valid_exact_valid",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_pos",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"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.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid_pos p h sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_content_pos p h' sl pos (contents p h sl pos) pos')) | [] | LowParse.Low.Base.Spec.valid_pos_frame_strong_1 | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl pos pos') l /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' /\
LowParse.Low.Base.Spec.valid_content_pos p
h'
sl
pos
(LowParse.Low.Base.Spec.contents p h sl pos)
pos') | {
"end_col": 36,
"end_line": 739,
"start_col": 2,
"start_line": 738
} |
FStar.Pervasives.Lemma | val valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos'))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos' | val valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos'))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos'))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] = | false | null | true | valid_exact_valid p h s pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_valid",
"Prims.unit",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact",
"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.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"LowParse.Low.Base.Spec.valid",
"Prims.Nil"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos'))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] | [] | LowParse.Low.Base.Spec.valid_exact_valid_pat | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_content_pos p
h
s
pos
(LowParse.Low.Base.Spec.contents_exact p h s pos pos')
pos')
[
SMTPat (LowParse.Low.Base.Spec.valid_exact p h s pos pos');
SMTPat (LowParse.Low.Base.Spec.valid p h s pos)
] | {
"end_col": 34,
"end_line": 717,
"start_col": 2,
"start_line": 717
} |
FStar.Pervasives.Lemma | val valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==>
(valid_exact p h s pos pos' /\ valid_exact p h' s pos pos' /\
contents_exact p h' s pos pos' == contents_exact p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')]
]
] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f () | val valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==>
(valid_exact p h s pos pos' /\ valid_exact p h' s pos pos' /\
contents_exact p h' s pos pos' == contents_exact p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')]
]
]
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==>
(valid_exact p h s pos pos' /\ valid_exact p h' s pos pos' /\
contents_exact p h' s pos pos' == contents_exact p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')]
]
] = | false | null | true | let f ()
: Lemma
(requires
(U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')))
(ensures
(valid_exact p h s pos pos' /\ valid_exact p h' s pos pos' /\
contents_exact p h' s pos pos' == contents_exact p h s pos pos')) =
valid_exact_equiv p h s pos pos';
valid_exact_equiv p h' s pos pos';
Classical.move_requires (contents_exact_eq p h s pos) pos';
Classical.move_requires (contents_exact_eq p h' s pos) pos';
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f () | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.l_or",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowStar.Monotonic.Buffer.modifies_buffer_from_to_elim",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"LowParse.Low.Base.Spec.valid_exact'",
"LowParse.Low.Base.Spec.contents_exact'",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Slice.live_slice",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"Prims.l_imp",
"Prims.Cons",
"FStar.Pervasives.smt_pat_or",
"Prims.list",
"FStar.Pervasives.smt_pat"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')]; | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==>
(valid_exact p h s pos pos' /\ valid_exact p h' s pos pos' /\
contents_exact p h' s pos pos' == contents_exact p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')]
]
] | [] | LowParse.Low.Base.Spec.valid_exact_frame | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h s /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l (LowParse.Slice.loc_slice_from_to s pos pos'))
(ensures
LowParse.Low.Base.Spec.valid_exact p h s pos pos' \/
LowParse.Low.Base.Spec.valid_exact p h' s pos pos' ==>
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
LowParse.Low.Base.Spec.valid_exact p h' s pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h' s pos pos' ==
LowParse.Low.Base.Spec.contents_exact p h s pos pos')
[
SMTPatOr [
[
SMTPat (LowParse.Low.Base.Spec.valid_exact p h s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.valid_exact p h' s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents_exact p h s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents_exact p h' s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
]
]
] | {
"end_col": 30,
"end_line": 602,
"start_col": 1,
"start_line": 587
} |
FStar.Pervasives.Lemma | val valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid_pos p h' sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos' | val valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid_pos p h' sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'))
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid_pos p h' sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos')) = | false | null | true | valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"LowParse.Low.Base.Spec.valid_exact_valid",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"Prims.l_and",
"LowParse.Slice.live_slice",
"LowParse.Low.Base.Spec.valid_pos",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"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.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid_pos p h' sl pos pos' /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures
(valid_pos p h sl pos pos' /\ valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos')) | [] | LowParse.Low.Base.Spec.valid_pos_frame_strong_2 | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\ LowParse.Low.Base.Spec.valid_pos p h' sl pos pos' /\
LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl pos pos') l /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_pos p h sl pos pos' /\
LowParse.Low.Base.Spec.valid_pos p h' sl pos pos' /\
LowParse.Low.Base.Spec.valid_content_pos p
h
sl
pos
(LowParse.Low.Base.Spec.contents p h' sl pos)
pos') | {
"end_col": 35,
"end_line": 763,
"start_col": 2,
"start_line": 762
} |
FStar.Pervasives.Lemma | val valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid p h sl pos /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)))
[
SMTPatOr
[
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h' | val valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid p h sl pos /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)))
[
SMTPatOr
[
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
]
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid p h sl pos /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)))
[
SMTPatOr
[
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] = | false | null | true | valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"LowParse.Low.Base.Spec.valid_pos_frame_strong",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.unit",
"Prims.l_and",
"LowParse.Slice.live_slice",
"LowParse.Low.Base.Spec.valid",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"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.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat_or",
"Prims.list",
"FStar.Pervasives.smt_pat",
"Prims.Nil",
"Prims.nat",
"LowParse.Low.Base.Spec.content_length"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]; | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h sl /\ valid p h sl pos /\ B.modifies l h h' /\
B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\
k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)))
[
SMTPatOr
[
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] | [] | LowParse.Low.Base.Spec.valid_frame_strong | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\ LowParse.Low.Base.Spec.valid p h sl pos /\
LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl
pos
(LowParse.Low.Base.Spec.get_valid_pos p h sl pos))
l /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_content_pos p
h'
sl
pos
(LowParse.Low.Base.Spec.contents p h sl pos)
(LowParse.Low.Base.Spec.get_valid_pos p h sl pos))
[
SMTPatOr [
[
SMTPat (LowParse.Low.Base.Spec.valid p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.content_length p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
]
]
] | {
"end_col": 67,
"end_line": 812,
"start_col": 2,
"start_line": 812
} |
Prims.GTot | val clens_compose_strong_pre (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x) | val clens_compose_strong_pre (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : GTot Type0
let clens_compose_strong_pre (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : GTot Type0 = | false | null | false | forall (x: t1). {:pattern (l12.clens_cond x)\/(l23.clens_cond (l12.clens_get x))}
l12.clens_cond x ==> l23.clens_cond (l12.clens_get x) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"sometrivial"
] | [
"LowParse.Low.Base.Spec.clens",
"Prims.l_Forall",
"Prims.l_imp",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_compose_strong_pre (#t1 #t2 #t3: Type) (l12: clens t1 t2) (l23: clens t2 t3) : GTot Type0 | [] | LowParse.Low.Base.Spec.clens_compose_strong_pre | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l12: LowParse.Low.Base.Spec.clens t1 t2 -> l23: LowParse.Low.Base.Spec.clens t2 t3
-> Prims.GTot Type0 | {
"end_col": 140,
"end_line": 1140,
"start_col": 2,
"start_line": 1140
} |
FStar.Pervasives.Lemma | val serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos pos': U32.t)
: Lemma
(requires
(live_slice h sl /\ U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
(bytes_of_slice_from_to h sl pos pos') `Seq.equal` (serialize s x)))
(ensures (valid_exact p h sl pos pos' /\ contents_exact p h sl pos pos' == x)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' | val serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos pos': U32.t)
: Lemma
(requires
(live_slice h sl /\ U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
(bytes_of_slice_from_to h sl pos pos') `Seq.equal` (serialize s x)))
(ensures (valid_exact p h sl pos pos' /\ contents_exact p h sl pos pos' == x))
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos pos': U32.t)
: Lemma
(requires
(live_slice h sl /\ U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
(bytes_of_slice_from_to h sl pos pos') `Seq.equal` (serialize s x)))
(ensures (valid_exact p h sl pos pos' /\ contents_exact p h sl pos pos' == x)) = | false | null | true | serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos';
contents_exact_eq p h sl pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.contents_exact_eq",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"LowParse.Spec.Base.serializer_correct_implies_complete",
"Prims.l_and",
"LowParse.Slice.live_slice",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"FStar.UInt32.v",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.serialize",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Slice.__proj__Mkslice__item__len",
"FStar.Seq.Base.equal",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos pos': U32.t)
: Lemma
(requires
(live_slice h sl /\ U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
(bytes_of_slice_from_to h sl pos pos') `Seq.equal` (serialize s x)))
(ensures (valid_exact p h sl pos pos' /\ contents_exact p h sl pos pos' == x)) | [] | LowParse.Low.Base.Spec.serialize_valid_exact | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s: LowParse.Spec.Base.serializer p ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
x: t ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\
FStar.UInt32.v pos + FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) ==
FStar.UInt32.v pos' /\ FStar.UInt32.v pos' <= FStar.UInt32.v (Mkslice?.len sl) /\
FStar.Seq.Base.equal (LowParse.Low.Base.Spec.bytes_of_slice_from_to h sl pos pos')
(LowParse.Spec.Base.serialize s x))
(ensures
LowParse.Low.Base.Spec.valid_exact p h sl pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h sl pos pos' == x) | {
"end_col": 35,
"end_line": 561,
"start_col": 2,
"start_line": 559
} |
FStar.Pervasives.Lemma | val clens_eq_intro
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Lemma (cl1.clens_cond x <==> cl2.clens_cond x)))
(get:
(x: t
-> Lemma (requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures
(cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))))
: Lemma (clens_eq cl1 cl2) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get) | val clens_eq_intro
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Lemma (cl1.clens_cond x <==> cl2.clens_cond x)))
(get:
(x: t
-> Lemma (requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures
(cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))))
: Lemma (clens_eq cl1 cl2)
let clens_eq_intro
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Lemma (cl1.clens_cond x <==> cl2.clens_cond x)))
(get:
(x: t
-> Lemma (requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures
(cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))))
: Lemma (clens_eq cl1 cl2) = | false | null | true | Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Low.Base.Spec.clens",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.l_and",
"Prims.eq2",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"FStar.Classical.move_requires",
"LowParse.Low.Base.Spec.clens_eq"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_eq_intro
(#t #t': Type)
(cl1 cl2: clens t t')
(cond: (x: t -> Lemma (cl1.clens_cond x <==> cl2.clens_cond x)))
(get:
(x: t
-> Lemma (requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures
(cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))))
: Lemma (clens_eq cl1 cl2) | [] | LowParse.Low.Base.Spec.clens_eq_intro | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cl1: LowParse.Low.Base.Spec.clens t t' ->
cl2: LowParse.Low.Base.Spec.clens t t' ->
cond:
(x: t
-> FStar.Pervasives.Lemma
(ensures Mkclens?.clens_cond cl1 x <==> Mkclens?.clens_cond cl2 x)) ->
get:
(x: t
-> FStar.Pervasives.Lemma
(requires Mkclens?.clens_cond cl1 x /\ Mkclens?.clens_cond cl2 x)
(ensures
Mkclens?.clens_cond cl1 x /\ Mkclens?.clens_cond cl2 x /\
Mkclens?.clens_get cl1 x == Mkclens?.clens_get cl2 x))
-> FStar.Pervasives.Lemma (ensures LowParse.Low.Base.Spec.clens_eq cl1 cl2) | {
"end_col": 54,
"end_line": 979,
"start_col": 2,
"start_line": 978
} |
FStar.Pervasives.Lemma | val valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_list p h sl pos pos'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 /\ live_slice h sl /\
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v sl.len))
[SMTPat (valid_list p h sl pos pos')] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos' | val valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_list p h sl pos pos'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 /\ live_slice h sl /\
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v sl.len))
[SMTPat (valid_list p h sl pos pos')]
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_list p h sl pos pos'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 /\ live_slice h sl /\
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v sl.len))
[SMTPat (valid_list p h sl pos pos')] = | false | null | true | valid_list_equiv p h sl pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_list_equiv",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list",
"Prims.squash",
"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",
"Prims.b2t",
"Prims.op_GreaterThan",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Slice.live_slice",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_list p h sl pos pos'))
(ensures
(k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 /\ live_slice h sl /\
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v sl.len))
[SMTPat (valid_list p h sl pos pos')] | [] | LowParse.Low.Base.Spec.valid_list_elim | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid_list p h sl pos pos')
(ensures
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_low k > 0 /\ LowParse.Slice.live_slice h sl /\
FStar.UInt32.v pos <= FStar.UInt32.v pos' /\
FStar.UInt32.v pos' <= FStar.UInt32.v (Mkslice?.len sl))
[SMTPat (LowParse.Low.Base.Spec.valid_list p h sl pos pos')] | {
"end_col": 34,
"end_line": 1905,
"start_col": 2,
"start_line": 1905
} |
Prims.GTot | val gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end | val gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 = | false | null | false | res <= Seq.length sl /\
(match parse p1 sl with
| Some (x1, consumed1) ->
(match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\ x2 == cl.clens_get x1 /\ res + consumed2 <= consumed1
| _ -> False)
| _ -> False) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Bytes.bytes",
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.consumed_length",
"FStar.Seq.Base.slice",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"Prims.eq2",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get",
"Prims.op_Addition",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.l_False",
"Prims.logical"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res: nat)
: GTot Type0 | [] | LowParse.Low.Base.Spec.gaccessor_post | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p1: LowParse.Spec.Base.parser k1 t1 ->
p2: LowParse.Spec.Base.parser k2 t2 ->
cl: LowParse.Low.Base.Spec.clens t1 t2 ->
sl: LowParse.Bytes.bytes ->
res: Prims.nat
-> Prims.GTot Type0 | {
"end_col": 5,
"end_line": 1209,
"start_col": 2,
"start_line": 1198
} |
FStar.Pervasives.Lemma | val valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos) | val valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos'))
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos')) = | false | null | true | valid_exact_equiv p h s pos pos';
contents_exact_eq p h s pos pos';
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"LowParse.Slice.bytes_of_slice_from",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact",
"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.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_content_pos p h s pos (contents_exact p h s pos pos') pos')) | [] | LowParse.Low.Base.Spec.valid_exact_valid | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_content_pos p
h
s
pos
(LowParse.Low.Base.Spec.contents_exact p h s pos pos')
pos') | {
"end_col": 91,
"end_line": 700,
"start_col": 2,
"start_line": 697
} |
FStar.Pervasives.Lemma | val valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures
(let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\
(let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos') | val valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures
(let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\
(let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos)))
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures
(let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\
(let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))) = | false | null | true | valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos';
Classical.move_requires (contents_exact_eq p h s pos) pos';
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos') | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.parse_strong_prefix",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.unit",
"FStar.Classical.move_requires",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact'",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.contents_exact'",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"FStar.UInt32.uint_to_t",
"Prims.int",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.content_length",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.Base.Spec.valid",
"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.squash",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures
(let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\
(let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))) | [] | LowParse.Low.Base.Spec.valid_valid_exact | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p h s pos /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
(let npos' = FStar.UInt32.v pos + LowParse.Low.Base.Spec.content_length p h s pos in
npos' <= FStar.UInt32.v (Mkslice?.len s) /\
(let pos' = FStar.UInt32.uint_to_t npos' in
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h s pos pos' ==
LowParse.Low.Base.Spec.contents p h s pos))) | {
"end_col": 91,
"end_line": 646,
"start_col": 2,
"start_line": 641
} |
FStar.Pervasives.Lemma | val list_length_append (#t: Type) (l1 l2: list t)
: Lemma (L.length (l1 `L.append` l2) == L.length l1 + L.length l2) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let list_length_append (#t: Type) (l1 l2: list t) : Lemma (L.length (l1 `L.append` l2) == L.length l1 + L.length l2) = L.append_length l1 l2 | val list_length_append (#t: Type) (l1 l2: list t)
: Lemma (L.length (l1 `L.append` l2) == L.length l1 + L.length l2)
let list_length_append (#t: Type) (l1 l2: list t)
: Lemma (L.length (l1 `L.append` l2) == L.length l1 + L.length l2) = | false | null | true | L.append_length l1 l2 | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"Prims.list",
"FStar.List.Tot.Properties.append_length",
"Prims.unit",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"Prims.int",
"FStar.List.Tot.Base.length",
"FStar.List.Tot.Base.append",
"Prims.op_Addition",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos'
val contents_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost (list t)
(requires (valid_list p h sl pos pos'))
(ensures (fun _ -> True))
(decreases (U32.v pos' - U32.v pos))
val contents_list_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (contents_list p h sl pos pos' == (
valid_list_equiv p h sl pos pos';
if pos = pos'
then []
else
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
)))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == []
))
= valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos
let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos'
))
(ensures (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
module L = FStar.List.Tot
let valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
pos <> pos' /\
valid_list p h sl pos pos'
))
(ensures (
pos <> pos' /\
valid_list p h sl pos pos' /\
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'
)))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
let rec valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h s pos pos'))
(ensures (
valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h s pos pos';
contents_list_eq p h s pos pos' ;
valid_list_equiv p h' s pos pos' ;
begin if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h s pos in
valid_list_frame_1 p h s pos1 pos' l h'
end end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h' s pos pos'
let rec valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h' s pos pos'))
(ensures (
valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h' s pos pos' ;
contents_list_eq p h' s pos pos' ;
valid_list_equiv p h s pos pos' ;
if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h' s pos in
valid_valid_exact p h' s pos;
valid_exact_valid p h s pos pos1;
valid_list_frame_2 p h s pos1 pos' l h'
end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h s pos pos'
let valid_list_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_list p h s pos pos' \/ valid_list p h' s pos pos') ==> (
valid_list p h s pos pos' /\
valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_list p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= Classical.move_requires (valid_list_frame_1 p h s pos pos' l) h';
Classical.move_requires (valid_list_frame_2 p h s pos pos' l) h'
let rec valid_list_append
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 pos3 : U32.t)
: Lemma
(requires (
valid_list p h sl pos1 pos2 /\
valid_list p h sl pos2 pos3
))
(ensures (
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 == contents_list p h sl pos1 pos2 `L.append` contents_list p h sl pos2 pos3
))
(decreases (U32.v pos2 - U32.v pos1))
= if pos1 = pos2
then
valid_list_nil p h sl pos1
else begin
valid_list_cons_recip p h sl pos1 pos2;
let pos15 = get_valid_pos p h sl pos1 in
valid_list_append p h sl pos15 pos2 pos3;
valid_list_cons p h sl pos1 pos3
end
let valid_list_snoc
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 : U32.t)
: Lemma
(requires (
valid_list p h sl pos1 pos2 /\
valid p h sl pos2
))
(ensures (
let pos3 = get_valid_pos p h sl pos2 in
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 == contents_list p h sl pos1 pos2 `L.append` [contents p h sl pos2]
))
= let pos3 = get_valid_pos p h sl pos2 in
valid_list_nil p h sl pos3;
valid_list_cons p h sl pos2 pos3;
valid_list_append p h sl pos1 pos2 pos3
(* size of a list of serialized data (should be taken from serialize_list) *)
val serialized_list_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (l: list t) : GTot nat
val serialized_list_length_nil (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) : Lemma
(serialized_list_length s [] == 0)
val serialized_list_length_cons (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (x: t) (q: list t) : Lemma
(serialized_list_length s (x :: q) == serialized_length s x + serialized_list_length s q)
val serialized_list_length_append (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (l1 l2: list t) : Lemma
(serialized_list_length s (List.Tot.append l1 l2) == serialized_list_length s l1 + serialized_list_length s l2)
val valid_list_serialized_list_length (#k: parser_kind) (#t: Type) (#p: parser k t) (s: serializer p) (h: HS.mem) (#rrel #rel: _) (input: slice rrel rel) (pos pos' : U32.t) : Lemma
(requires (
valid_list p h input pos pos'
))
(ensures (
serialized_list_length s (contents_list p h input pos pos') == U32.v pos' - U32.v pos
))
(decreases (U32.v pos' - U32.v pos))
val serialized_list_length_constant_size
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_high == Some k.parser_kind_low})
(l: list t)
: Lemma
(ensures (
serialized_list_length s l == L.length l `Prims.op_Multiply` k.parser_kind_low
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val list_length_append (#t: Type) (l1 l2: list t)
: Lemma (L.length (l1 `L.append` l2) == L.length l1 + L.length l2) | [] | LowParse.Low.Base.Spec.list_length_append | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l1: Prims.list t -> l2: Prims.list t
-> FStar.Pervasives.Lemma
(ensures
FStar.List.Tot.Base.length (l1 @ l2) ==
FStar.List.Tot.Base.length l1 + FStar.List.Tot.Base.length l2) | {
"end_col": 140,
"end_line": 2178,
"start_col": 119,
"start_line": 2178
} |
FStar.Pervasives.Lemma | val valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid p h sl pos /\ valid_list p h sl (get_valid_pos p h sl pos) pos'))
(ensures
(valid p h sl pos /\ valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' ==
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos'
))
(ensures (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos' | val valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid p h sl pos /\ valid_list p h sl (get_valid_pos p h sl pos) pos'))
(ensures
(valid p h sl pos /\ valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' ==
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'))
let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid p h sl pos /\ valid_list p h sl (get_valid_pos p h sl pos) pos'))
(ensures
(valid p h sl pos /\ valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' ==
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos')) = | false | null | true | valid_list_equiv p h sl pos pos';
contents_list_eq p h sl pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.contents_list_eq",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list_equiv",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.valid_list",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.squash",
"Prims.eq2",
"Prims.list",
"LowParse.Low.Base.Spec.contents_list",
"Prims.Cons",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos'
val contents_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost (list t)
(requires (valid_list p h sl pos pos'))
(ensures (fun _ -> True))
(decreases (U32.v pos' - U32.v pos))
val contents_list_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (contents_list p h sl pos pos' == (
valid_list_equiv p h sl pos pos';
if pos = pos'
then []
else
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
)))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == []
))
= valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos
let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos'
))
(ensures (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid p h sl pos /\ valid_list p h sl (get_valid_pos p h sl pos) pos'))
(ensures
(valid p h sl pos /\ valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' ==
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos')) | [] | LowParse.Low.Base.Spec.valid_list_cons | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p h sl pos /\
LowParse.Low.Base.Spec.valid_list p
h
sl
(LowParse.Low.Base.Spec.get_valid_pos p h sl pos)
pos')
(ensures
LowParse.Low.Base.Spec.valid p h sl pos /\
LowParse.Low.Base.Spec.valid_list p
h
sl
(LowParse.Low.Base.Spec.get_valid_pos p h sl pos)
pos' /\ LowParse.Low.Base.Spec.valid_list p h sl pos pos' /\
LowParse.Low.Base.Spec.contents_list p h sl pos pos' ==
LowParse.Low.Base.Spec.contents p h sl pos ::
LowParse.Low.Base.Spec.contents_list p
h
sl
(LowParse.Low.Base.Spec.get_valid_pos p h sl pos)
pos') | {
"end_col": 34,
"end_line": 1978,
"start_col": 2,
"start_line": 1977
} |
FStar.Pervasives.Lemma | val valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'))
(ensures
(U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2')) | val valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'))
(ensures
(U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'))
(ensures
(U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) = | false | null | true | valid_exact_equiv p h1 s1 pos1 pos1';
valid_exact_equiv p h2 s2 pos2 pos2';
contents_exact_eq p h1 s1 pos1 pos1';
contents_exact_eq p h2 s2 pos2 pos2';
parser_kind_prop_equiv k p;
assert (injective_precond p
(bytes_of_slice_from_to h1 s1 pos1 pos1')
(bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p
(bytes_of_slice_from_to h1 s1 pos1 pos1')
(bytes_of_slice_from_to h2 s2 pos2 pos2')) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims._assert",
"LowParse.Spec.Base.injective_postcond",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.unit",
"LowParse.Spec.Base.injective_precond",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Low.Base.Spec.contents_exact_eq",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.squash",
"Prims.int",
"Prims.op_Subtraction",
"FStar.UInt32.v",
"LowParse.Bytes.bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'))
(ensures
(U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) | [] | LowParse.Low.Base.Spec.valid_exact_ext_elim | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h1: FStar.Monotonic.HyperStack.mem ->
s1: LowParse.Slice.slice rrel1 rel1 ->
pos1: FStar.UInt32.t ->
pos1': FStar.UInt32.t ->
h2: FStar.Monotonic.HyperStack.mem ->
s2: LowParse.Slice.slice rrel2 rel2 ->
pos2: FStar.UInt32.t ->
pos2': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_exact p h1 s1 pos1 pos1' /\
LowParse.Low.Base.Spec.valid_exact p h2 s2 pos2 pos2' /\
LowParse.Low.Base.Spec.contents_exact p h1 s1 pos1 pos1' ==
LowParse.Low.Base.Spec.contents_exact p h2 s2 pos2 pos2')
(ensures
FStar.UInt32.v pos2' - FStar.UInt32.v pos2 == FStar.UInt32.v pos1' - FStar.UInt32.v pos1 /\
LowParse.Low.Base.Spec.bytes_of_slice_from_to h1 s1 pos1 pos1' ==
LowParse.Low.Base.Spec.bytes_of_slice_from_to h2 s2 pos2 pos2') | {
"end_col": 115,
"end_line": 875,
"start_col": 2,
"start_line": 869
} |
Prims.Ghost | val gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input | val gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res)) = | false | null | false | g input | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"Prims.squash",
"LowParse.Low.Base.Spec.clens_eq",
"LowParse.Bytes.bytes",
"Prims.nat",
"Prims.l_True",
"LowParse.Low.Base.Spec.gaccessor_post'"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res)) | [] | LowParse.Low.Base.Spec.gaccessor_ext' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
g: LowParse.Low.Base.Spec.gaccessor p1 p2 cl ->
cl': LowParse.Low.Base.Spec.clens t1 t2 ->
sq: Prims.squash (LowParse.Low.Base.Spec.clens_eq cl cl') ->
input: LowParse.Bytes.bytes
-> Prims.Ghost Prims.nat | {
"end_col": 9,
"end_line": 1515,
"start_col": 2,
"start_line": 1515
} |
FStar.Pervasives.Lemma | val slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid p1 h sl pos /\ cl.clens_cond (contents p1 h sl pos) /\ B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)))
(ensures
(valid p1 h' sl pos /\ cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos))
[
SMTPatOr
[
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')]
]
] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h' | val slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid p1 h sl pos /\ cl.clens_cond (contents p1 h sl pos) /\ B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)))
(ensures
(valid p1 h' sl pos /\ cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos))
[
SMTPatOr
[
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')]
]
]
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid p1 h sl pos /\ cl.clens_cond (contents p1 h sl pos) /\ B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)))
(ensures
(valid p1 h' sl pos /\ cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos))
[
SMTPatOr
[
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')]
]
] = | false | null | true | valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"LowStar.Monotonic.Buffer.modifies_buffer_from_to_elim",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"LowParse.Slice.__proj__Mkslice__item__len",
"Prims.unit",
"LowParse.Low.Base.Spec.slice_access_eq",
"LowParse.Low.Base.Spec.valid_facts",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.contents",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from",
"Prims.squash",
"Prims.eq2",
"LowParse.Low.Base.Spec.slice_access",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat_or",
"Prims.list",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')]; | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(valid p1 h sl pos /\ cl.clens_cond (contents p1 h sl pos) /\ B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)))
(ensures
(valid p1 h' sl pos /\ cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos))
[
SMTPatOr
[
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')]
]
] | [] | LowParse.Low.Base.Spec.slice_access_frame_weak | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
g: LowParse.Low.Base.Spec.gaccessor p1 p2 cl ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p1 h sl pos /\
Mkclens?.clens_cond cl (LowParse.Low.Base.Spec.contents p1 h sl pos) /\
LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l (LowParse.Slice.loc_slice_from sl pos))
(ensures
LowParse.Low.Base.Spec.valid p1 h' sl pos /\
Mkclens?.clens_cond cl (LowParse.Low.Base.Spec.contents p1 h' sl pos) /\
LowParse.Low.Base.Spec.slice_access h' g sl pos ==
LowParse.Low.Base.Spec.slice_access h g sl pos)
[
SMTPatOr [
[
SMTPat (LowParse.Low.Base.Spec.slice_access h g sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.slice_access h' g sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
]
]
] | {
"end_col": 58,
"end_line": 1812,
"start_col": 2,
"start_line": 1808
} |
FStar.Pervasives.Lemma | val valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\
valid_list p h s pos pos'))
(ensures
(valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos'))
(decreases (U32.v pos' - U32.v pos)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h s pos pos'))
(ensures (
valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h s pos pos';
contents_list_eq p h s pos pos' ;
valid_list_equiv p h' s pos pos' ;
begin if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h s pos in
valid_list_frame_1 p h s pos1 pos' l h'
end end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h' s pos pos' | val valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\
valid_list p h s pos pos'))
(ensures
(valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos'))
(decreases (U32.v pos' - U32.v pos))
let rec valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\
valid_list p h s pos pos'))
(ensures
(valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos'))
(decreases (U32.v pos' - U32.v pos)) = | false | null | true | valid_list_equiv p h s pos pos';
contents_list_eq p h s pos pos';
valid_list_equiv p h' s pos pos';
if pos = pos'
then ()
else
(let pos1 = get_valid_pos p h s pos in
valid_list_frame_1 p h s pos1 pos' l h');
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h' s pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma",
""
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"LowParse.Low.Base.Spec.contents_list_eq",
"Prims.unit",
"LowStar.Monotonic.Buffer.modifies_buffer_from_to_elim",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"Prims.op_Equality",
"Prims.bool",
"LowParse.Low.Base.Spec.valid_list_frame_1",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.valid_list_equiv",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.valid_list",
"Prims.squash",
"Prims.eq2",
"Prims.list",
"LowParse.Low.Base.Spec.contents_list",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos'
val contents_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost (list t)
(requires (valid_list p h sl pos pos'))
(ensures (fun _ -> True))
(decreases (U32.v pos' - U32.v pos))
val contents_list_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (contents_list p h sl pos pos' == (
valid_list_equiv p h sl pos pos';
if pos = pos'
then []
else
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
)))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == []
))
= valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos
let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos'
))
(ensures (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
module L = FStar.List.Tot
let valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
pos <> pos' /\
valid_list p h sl pos pos'
))
(ensures (
pos <> pos' /\
valid_list p h sl pos pos' /\
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'
)))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
let rec valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h s pos pos'))
(ensures (
valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\
valid_list p h s pos pos'))
(ensures
(valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos'))
(decreases (U32.v pos' - U32.v pos)) | [
"recursion"
] | LowParse.Low.Base.Spec.valid_list_frame_1 | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l (LowParse.Slice.loc_slice_from_to s pos pos') /\
LowParse.Low.Base.Spec.valid_list p h s pos pos')
(ensures
LowParse.Low.Base.Spec.valid_list p h s pos pos' /\
LowParse.Low.Base.Spec.valid_list p h' s pos pos' /\
LowParse.Low.Base.Spec.contents_list p h' s pos pos' ==
LowParse.Low.Base.Spec.contents_list p h s pos pos')
(decreases FStar.UInt32.v pos' - FStar.UInt32.v pos) | {
"end_col": 34,
"end_line": 2034,
"start_col": 2,
"start_line": 2024
} |
FStar.Pervasives.Lemma | val slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p1 h sl pos /\ cl.clens_cond (contents p1 h sl pos)))
(ensures
(let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\ contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos))
[SMTPat (slice_access h g sl pos)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res | val slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p1 h sl pos /\ cl.clens_cond (contents p1 h sl pos)))
(ensures
(let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\ contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos))
[SMTPat (slice_access h g sl pos)]
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p1 h sl pos /\ cl.clens_cond (contents p1 h sl pos)))
(ensures
(let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\ contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos))
[SMTPat (slice_access h g sl pos)] = | false | null | true | slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_facts",
"LowParse.Low.Base.Spec.slice_access'",
"Prims.unit",
"FStar.Pervasives.assert_norm",
"Prims.eq2",
"Prims.int",
"Prims.pow2",
"LowParse.Low.Base.Spec.slice_access_eq",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.contents",
"Prims.squash",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.content_length",
"LowParse.Low.Base.Spec.slice_access",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p1 h sl pos /\ cl.clens_cond (contents p1 h sl pos)))
(ensures
(let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\ contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos))
[SMTPat (slice_access h g sl pos)] | [] | LowParse.Low.Base.Spec.slice_access_post | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
g: LowParse.Low.Base.Spec.gaccessor p1 p2 cl ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p1 h sl pos /\
Mkclens?.clens_cond cl (LowParse.Low.Base.Spec.contents p1 h sl pos))
(ensures
(let pos' = LowParse.Low.Base.Spec.slice_access h g sl pos in
LowParse.Low.Base.Spec.valid p2 h sl pos' /\
LowParse.Low.Base.Spec.contents p2 h sl pos' ==
Mkclens?.clens_get cl (LowParse.Low.Base.Spec.contents p1 h sl pos) /\
FStar.UInt32.v pos <= FStar.UInt32.v pos' /\
FStar.UInt32.v pos' + LowParse.Low.Base.Spec.content_length p2 h sl pos' <=
FStar.UInt32.v pos + LowParse.Low.Base.Spec.content_length p1 h sl pos))
[SMTPat (LowParse.Low.Base.Spec.slice_access h g sl pos)] | {
"end_col": 25,
"end_line": 1775,
"start_col": 2,
"start_line": 1771
} |
FStar.Pervasives.Lemma | val valid_list_append
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 pos3: U32.t)
: Lemma (requires (valid_list p h sl pos1 pos2 /\ valid_list p h sl pos2 pos3))
(ensures
(valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 ==
(contents_list p h sl pos1 pos2)
`L.append`
(contents_list p h sl pos2 pos3)))
(decreases (U32.v pos2 - U32.v pos1)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec valid_list_append
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 pos3 : U32.t)
: Lemma
(requires (
valid_list p h sl pos1 pos2 /\
valid_list p h sl pos2 pos3
))
(ensures (
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 == contents_list p h sl pos1 pos2 `L.append` contents_list p h sl pos2 pos3
))
(decreases (U32.v pos2 - U32.v pos1))
= if pos1 = pos2
then
valid_list_nil p h sl pos1
else begin
valid_list_cons_recip p h sl pos1 pos2;
let pos15 = get_valid_pos p h sl pos1 in
valid_list_append p h sl pos15 pos2 pos3;
valid_list_cons p h sl pos1 pos3
end | val valid_list_append
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 pos3: U32.t)
: Lemma (requires (valid_list p h sl pos1 pos2 /\ valid_list p h sl pos2 pos3))
(ensures
(valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 ==
(contents_list p h sl pos1 pos2)
`L.append`
(contents_list p h sl pos2 pos3)))
(decreases (U32.v pos2 - U32.v pos1))
let rec valid_list_append
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 pos3: U32.t)
: Lemma (requires (valid_list p h sl pos1 pos2 /\ valid_list p h sl pos2 pos3))
(ensures
(valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 ==
(contents_list p h sl pos1 pos2)
`L.append`
(contents_list p h sl pos2 pos3)))
(decreases (U32.v pos2 - U32.v pos1)) = | false | null | true | if pos1 = pos2
then valid_list_nil p h sl pos1
else
(valid_list_cons_recip p h sl pos1 pos2;
let pos15 = get_valid_pos p h sl pos1 in
valid_list_append p h sl pos15 pos2 pos3;
valid_list_cons p h sl pos1 pos3) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma",
""
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"Prims.op_Equality",
"LowParse.Low.Base.Spec.valid_list_nil",
"Prims.bool",
"LowParse.Low.Base.Spec.valid_list_cons",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list_append",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.valid_list_cons_recip",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_list",
"Prims.squash",
"Prims.eq2",
"Prims.list",
"LowParse.Low.Base.Spec.contents_list",
"FStar.List.Tot.Base.append",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos'
val contents_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost (list t)
(requires (valid_list p h sl pos pos'))
(ensures (fun _ -> True))
(decreases (U32.v pos' - U32.v pos))
val contents_list_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (contents_list p h sl pos pos' == (
valid_list_equiv p h sl pos pos';
if pos = pos'
then []
else
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
)))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == []
))
= valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos
let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos'
))
(ensures (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
module L = FStar.List.Tot
let valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
pos <> pos' /\
valid_list p h sl pos pos'
))
(ensures (
pos <> pos' /\
valid_list p h sl pos pos' /\
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'
)))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
let rec valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h s pos pos'))
(ensures (
valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h s pos pos';
contents_list_eq p h s pos pos' ;
valid_list_equiv p h' s pos pos' ;
begin if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h s pos in
valid_list_frame_1 p h s pos1 pos' l h'
end end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h' s pos pos'
let rec valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h' s pos pos'))
(ensures (
valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h' s pos pos' ;
contents_list_eq p h' s pos pos' ;
valid_list_equiv p h s pos pos' ;
if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h' s pos in
valid_valid_exact p h' s pos;
valid_exact_valid p h s pos pos1;
valid_list_frame_2 p h s pos1 pos' l h'
end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h s pos pos'
let valid_list_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_list p h s pos pos' \/ valid_list p h' s pos pos') ==> (
valid_list p h s pos pos' /\
valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_list p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= Classical.move_requires (valid_list_frame_1 p h s pos pos' l) h';
Classical.move_requires (valid_list_frame_2 p h s pos pos' l) h'
let rec valid_list_append
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 pos3 : U32.t)
: Lemma
(requires (
valid_list p h sl pos1 pos2 /\
valid_list p h sl pos2 pos3
))
(ensures (
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 == contents_list p h sl pos1 pos2 `L.append` contents_list p h sl pos2 pos3
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_list_append
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 pos3: U32.t)
: Lemma (requires (valid_list p h sl pos1 pos2 /\ valid_list p h sl pos2 pos3))
(ensures
(valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 ==
(contents_list p h sl pos1 pos2)
`L.append`
(contents_list p h sl pos2 pos3)))
(decreases (U32.v pos2 - U32.v pos1)) | [
"recursion"
] | LowParse.Low.Base.Spec.valid_list_append | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos1: FStar.UInt32.t ->
pos2: FStar.UInt32.t ->
pos3: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_list p h sl pos1 pos2 /\
LowParse.Low.Base.Spec.valid_list p h sl pos2 pos3)
(ensures
LowParse.Low.Base.Spec.valid_list p h sl pos1 pos3 /\
LowParse.Low.Base.Spec.contents_list p h sl pos1 pos3 ==
LowParse.Low.Base.Spec.contents_list p h sl pos1 pos2 @
LowParse.Low.Base.Spec.contents_list p h sl pos2 pos3)
(decreases FStar.UInt32.v pos2 - FStar.UInt32.v pos1) | {
"end_col": 5,
"end_line": 2120,
"start_col": 2,
"start_line": 2112
} |
FStar.Pervasives.Lemma | val valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ k.parser_kind_subkind == Some ParserStrong /\
(let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\ U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\
(let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))))
(ensures
(valid_content_pos p
h2
s2
pos2
(contents p h1 s1 pos1)
(pos2 `U32.add` ((get_valid_pos p h1 s1 pos1) `U32.sub` pos1)))) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2' | val valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ k.parser_kind_subkind == Some ParserStrong /\
(let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\ U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\
(let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))))
(ensures
(valid_content_pos p
h2
s2
pos2
(contents p h1 s1 pos1)
(pos2 `U32.add` ((get_valid_pos p h1 s1 pos1) `U32.sub` pos1))))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ k.parser_kind_subkind == Some ParserStrong /\
(let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\ U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\
(let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))))
(ensures
(valid_content_pos p
h2
s2
pos2
(contents p h1 s1 pos1)
(pos2 `U32.add` ((get_valid_pos p h1 s1 pos1) `U32.sub` pos1)))) = | false | null | true | let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1';
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2';
valid_exact_valid p h2 s2 pos2 pos2' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_valid",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact_ext_intro",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"FStar.UInt32.add",
"FStar.UInt32.sub",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"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.Slice.live_slice",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"Prims.op_Subtraction",
"LowParse.Slice.__proj__Mkslice__item__len",
"FStar.Seq.Base.equal",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.squash",
"LowParse.Low.Base.Spec.valid_content_pos",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ k.parser_kind_subkind == Some ParserStrong /\
(let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\ U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\
(let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))))
(ensures
(valid_content_pos p
h2
s2
pos2
(contents p h1 s1 pos1)
(pos2 `U32.add` ((get_valid_pos p h1 s1 pos1) `U32.sub` pos1)))) | [] | LowParse.Low.Base.Spec.valid_ext_intro | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h1: FStar.Monotonic.HyperStack.mem ->
s1: LowParse.Slice.slice rrel1 rel1 ->
pos1: FStar.UInt32.t ->
h2: FStar.Monotonic.HyperStack.mem ->
s2: LowParse.Slice.slice rrel2 rel2 ->
pos2: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p h1 s1 pos1 /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
(let pos1' = LowParse.Low.Base.Spec.get_valid_pos p h1 s1 pos1 in
LowParse.Slice.live_slice h2 s2 /\
FStar.UInt32.v pos2 + (FStar.UInt32.v pos1' - FStar.UInt32.v pos1) <=
FStar.UInt32.v (Mkslice?.len s2) /\
(let pos2' = FStar.UInt32.add pos2 (FStar.UInt32.sub pos1' pos1) in
FStar.Seq.Base.equal (LowParse.Low.Base.Spec.bytes_of_slice_from_to h1 s1 pos1 pos1')
(LowParse.Low.Base.Spec.bytes_of_slice_from_to h2 s2 pos2 pos2'))))
(ensures
LowParse.Low.Base.Spec.valid_content_pos p
h2
s2
pos2
(LowParse.Low.Base.Spec.contents p h1 s1 pos1)
(FStar.UInt32.add pos2
(FStar.UInt32.sub (LowParse.Low.Base.Spec.get_valid_pos p h1 s1 pos1) pos1))) | {
"end_col": 38,
"end_line": 906,
"start_col": 1,
"start_line": 902
} |
FStar.Pervasives.Lemma | val valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos)) (ensures (valid' p h s pos)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos | val valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos)) (ensures (valid' p h s pos))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos)) (ensures (valid' p h s pos)) = | false | null | true | valid_equiv p h s pos | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_equiv",
"Prims.unit",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"LowParse.Low.Base.Spec.valid'",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos)) (ensures (valid' p h s pos)) | [] | LowParse.Low.Base.Spec.valid_elim | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid p h s pos)
(ensures LowParse.Low.Base.Spec.valid' p h s pos) | {
"end_col": 23,
"end_line": 72,
"start_col": 2,
"start_line": 72
} |
FStar.Pervasives.Lemma | val valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\ live_slice h s))
[SMTPat (valid p h s pos)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos | val valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\ live_slice h s))
[SMTPat (valid p h s pos)]
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\ live_slice h s))
[SMTPat (valid p h s pos)] = | false | null | true | parser_kind_prop_equiv k p;
valid_equiv p h s pos | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_equiv",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Slice.live_slice",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma (requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\ live_slice h s))
[SMTPat (valid p h s pos)] | [] | LowParse.Low.Base.Spec.valid_elim' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid p h s pos)
(ensures
FStar.UInt32.v pos + Mkparser_kind'?.parser_kind_low k <= FStar.UInt32.v (Mkslice?.len s) /\
LowParse.Slice.live_slice h s)
[SMTPat (LowParse.Low.Base.Spec.valid p h s pos)] | {
"end_col": 23,
"end_line": 88,
"start_col": 2,
"start_line": 87
} |
FStar.Pervasives.Lemma | val valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos'))
(ensures
(live_slice h s /\ U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\
(let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\
(match k.parser_kind_high with
| Some high -> length <= high
| _ -> True))))
[SMTPat (valid_exact p h s pos pos')] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos' | val valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos'))
(ensures
(live_slice h s /\ U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\
(let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\
(match k.parser_kind_high with
| Some high -> length <= high
| _ -> True))))
[SMTPat (valid_exact p h s pos pos')]
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos'))
(ensures
(live_slice h s /\ U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\
(let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\
(match k.parser_kind_high with
| Some high -> length <= high
| _ -> True))))
[SMTPat (valid_exact p h s pos pos')] = | false | null | true | parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Low.Base.Spec.valid_exact",
"Prims.squash",
"Prims.l_and",
"LowParse.Slice.live_slice",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.nat",
"FStar.Pervasives.Native.option",
"Prims.l_True",
"Prims.logical",
"Prims.int",
"Prims.op_Subtraction",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
)))) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_exact p h s pos pos'))
(ensures
(live_slice h s /\ U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\
(let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\
(match k.parser_kind_high with
| Some high -> length <= high
| _ -> True))))
[SMTPat (valid_exact p h s pos pos')] | [] | LowParse.Low.Base.Spec.valid_exact_elim' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma (requires LowParse.Low.Base.Spec.valid_exact p h s pos pos')
(ensures
LowParse.Slice.live_slice h s /\ FStar.UInt32.v pos <= FStar.UInt32.v pos' /\
FStar.UInt32.v pos' <= FStar.UInt32.v (Mkslice?.len s) /\
(let length = FStar.UInt32.v pos' - FStar.UInt32.v pos in
Mkparser_kind'?.parser_kind_low k <= length /\
(match Mkparser_kind'?.parser_kind_high k with
| FStar.Pervasives.Native.Some #_ high -> length <= high
| _ -> Prims.l_True)))
[SMTPat (LowParse.Low.Base.Spec.valid_exact p h s pos pos')] | {
"end_col": 34,
"end_line": 474,
"start_col": 2,
"start_line": 473
} |
Prims.Ghost | val content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures
(fun res ->
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max))) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed | val content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures
(fun res ->
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max)))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures
(fun res ->
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max))) = | false | null | false | let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Spec.Base.consumed_length",
"LowParse.Slice.bytes_of_slice_from",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"Prims.nat",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Low.Base.Spec.valid'",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.l_True",
"Prims.logical"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures
(fun res ->
U32.v pos + res <= U32.v sl.len /\ k.parser_kind_low <= res /\
(match k.parser_kind_high with
| None -> True
| Some max -> res <= max))) | [] | LowParse.Low.Base.Spec.content_length' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> Prims.Ghost Prims.nat | {
"end_col": 10,
"end_line": 147,
"start_col": 1,
"start_line": 145
} |
FStar.Pervasives.Lemma | val valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==>
(contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos))) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos | val valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==>
(contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos)))
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==>
(contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos))) = | false | null | true | valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Classical.move_requires",
"LowParse.Low.Base.Spec.valid",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid'",
"Prims.eq2",
"Prims.nat",
"LowParse.Low.Base.Spec.content_length",
"LowParse.Low.Base.Spec.content_length'",
"LowParse.Low.Base.Spec.content_length_eq_gen",
"Prims.unit",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.contents'",
"LowParse.Low.Base.Spec.contents_eq",
"LowParse.Low.Base.Spec.valid_equiv",
"Prims.l_True",
"Prims.squash",
"Prims.l_iff",
"Prims.l_imp",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==>
(contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos))) | [] | LowParse.Low.Base.Spec.valid_facts | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(ensures
(LowParse.Low.Base.Spec.valid p h sl pos <==> LowParse.Low.Base.Spec.valid' p h sl pos) /\
(LowParse.Low.Base.Spec.valid p h sl pos ==>
LowParse.Low.Base.Spec.contents p h sl pos == LowParse.Low.Base.Spec.contents' p h sl pos /\
LowParse.Low.Base.Spec.content_length p h sl pos ==
LowParse.Low.Base.Spec.content_length' p h sl pos)) | {
"end_col": 60,
"end_line": 234,
"start_col": 2,
"start_line": 232
} |
FStar.Pervasives.Lemma | val valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos' | val valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] = | false | null | true | valid_pos_valid_exact p h s pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_pos_valid_exact",
"Prims.unit",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_pos",
"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.squash",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Low.Base.Spec.contents_exact",
"LowParse.Low.Base.Spec.contents",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat",
"LowParse.Low.Base.Spec.valid",
"Prims.Nil"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (valid_exact p h s pos pos' /\ contents_exact p h s pos pos' == contents p h s pos))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)] | [] | LowParse.Low.Base.Spec.valid_pos_valid_exact_pat | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_pos p h s pos pos' /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong)
(ensures
LowParse.Low.Base.Spec.valid_exact p h s pos pos' /\
LowParse.Low.Base.Spec.contents_exact p h s pos pos' ==
LowParse.Low.Base.Spec.contents p h s pos)
[
SMTPat (LowParse.Low.Base.Spec.valid_exact p h s pos pos');
SMTPat (LowParse.Low.Base.Spec.valid p h s pos)
] | {
"end_col": 38,
"end_line": 681,
"start_col": 2,
"start_line": 681
} |
Prims.GTot | val clens_eq (#t #t': Type) (cl1 cl2: clens t t') : GTot Type0 | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x)) | val clens_eq (#t #t': Type) (cl1 cl2: clens t t') : GTot Type0
let clens_eq (#t #t': Type) (cl1 cl2: clens t t') : GTot Type0 = | false | null | false | (forall (x: t). {:pattern (cl1.clens_cond x)\/(cl2.clens_cond x)}
cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t). {:pattern (cl1.clens_get x)\/(cl2.clens_get x)}
(cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x)) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"sometrivial"
] | [
"LowParse.Low.Base.Spec.clens",
"Prims.l_and",
"Prims.l_Forall",
"Prims.l_iff",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"Prims.l_imp",
"Prims.l_or",
"Prims.eq2",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_get"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
} | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val clens_eq (#t #t': Type) (cl1 cl2: clens t t') : GTot Type0 | [] | LowParse.Low.Base.Spec.clens_eq | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | cl1: LowParse.Low.Base.Spec.clens t t' -> cl2: LowParse.Low.Base.Spec.clens t t' -> Prims.GTot Type0 | {
"end_col": 149,
"end_line": 961,
"start_col": 2,
"start_line": 960
} |
FStar.Pervasives.Lemma | val valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures
((valid p h sl pos \/ valid p h' sl pos) ==>
(valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos))))
[
SMTPatOr
[
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f () | val valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures
((valid p h sl pos \/ valid p h' sl pos) ==>
(valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos))))
[
SMTPatOr
[
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
]
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures
((valid p h sl pos \/ valid p h' sl pos) ==>
(valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos))))
[
SMTPatOr
[
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] = | false | null | true | let f ()
: Lemma (requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures
(valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos))) =
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f () | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Slice.__proj__Mkslice__item__len",
"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.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Low.Base.Spec.valid_facts",
"LowStar.Monotonic.Buffer.modifies_buffer_from_to_elim",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"LowParse.Slice.live_slice",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from",
"Prims.l_imp",
"Prims.Cons",
"FStar.Pervasives.smt_pat_or",
"Prims.list",
"FStar.Pervasives.smt_pat",
"Prims.nat",
"LowParse.Low.Base.Spec.content_length"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]; | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures
((valid p h sl pos \/ valid p h' sl pos) ==>
(valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos))))
[
SMTPatOr
[
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')]
]
] | [] | LowParse.Low.Base.Spec.valid_frame | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h sl /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from sl pos) l)
(ensures
LowParse.Low.Base.Spec.valid p h sl pos \/ LowParse.Low.Base.Spec.valid p h' sl pos ==>
LowParse.Low.Base.Spec.valid p h sl pos /\
LowParse.Low.Base.Spec.valid_content_pos p
h'
sl
pos
(LowParse.Low.Base.Spec.contents p h sl pos)
(LowParse.Low.Base.Spec.get_valid_pos p h sl pos))
[
SMTPatOr [
[
SMTPat (LowParse.Low.Base.Spec.valid p h sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.valid p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents p h sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.content_length p h sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.content_length p h' sl pos);
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
]
]
] | {
"end_col": 30,
"end_line": 386,
"start_col": 1,
"start_line": 375
} |
FStar.Pervasives.Lemma | val valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\ U32.v pos2' <= U32.v s2.len /\
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))
(ensures
(valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' | val valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\ U32.v pos2' <= U32.v s2.len /\
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))
(ensures
(valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'))
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\ U32.v pos2' <= U32.v s2.len /\
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))
(ensures
(valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1')) = | false | null | true | valid_exact_equiv p h1 s1 pos1 pos1';
valid_exact_equiv p h2 s2 pos2 pos2';
contents_exact_eq p h1 s1 pos1 pos1';
contents_exact_eq p h2 s2 pos2 pos2' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.contents_exact_eq",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_exact_equiv",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_exact",
"LowParse.Slice.live_slice",
"Prims.eq2",
"Prims.int",
"Prims.op_Subtraction",
"FStar.UInt32.v",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"LowParse.Slice.__proj__Mkslice__item__len",
"FStar.Seq.Base.equal",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.squash",
"LowParse.Low.Base.Spec.contents_exact",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1 pos1': U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2 pos2': U32.t)
: Lemma
(requires
(valid_exact p h1 s1 pos1 pos1' /\ live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\ U32.v pos2' <= U32.v s2.len /\
(bytes_of_slice_from_to h1 s1 pos1 pos1')
`Seq.equal`
(bytes_of_slice_from_to h2 s2 pos2 pos2')))
(ensures
(valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1')) | [] | LowParse.Low.Base.Spec.valid_exact_ext_intro | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h1: FStar.Monotonic.HyperStack.mem ->
s1: LowParse.Slice.slice rrel1 rel1 ->
pos1: FStar.UInt32.t ->
pos1': FStar.UInt32.t ->
h2: FStar.Monotonic.HyperStack.mem ->
s2: LowParse.Slice.slice rrel2 rel2 ->
pos2: FStar.UInt32.t ->
pos2': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_exact p h1 s1 pos1 pos1' /\ LowParse.Slice.live_slice h2 s2 /\
FStar.UInt32.v pos1' - FStar.UInt32.v pos1 == FStar.UInt32.v pos2' - FStar.UInt32.v pos2 /\
FStar.UInt32.v pos2' <= FStar.UInt32.v (Mkslice?.len s2) /\
FStar.Seq.Base.equal (LowParse.Low.Base.Spec.bytes_of_slice_from_to h1 s1 pos1 pos1')
(LowParse.Low.Base.Spec.bytes_of_slice_from_to h2 s2 pos2 pos2'))
(ensures
LowParse.Low.Base.Spec.valid_exact p h2 s2 pos2 pos2' /\
LowParse.Low.Base.Spec.contents_exact p h2 s2 pos2 pos2' ==
LowParse.Low.Base.Spec.contents_exact p h1 s1 pos1 pos1') | {
"end_col": 38,
"end_line": 843,
"start_col": 2,
"start_line": 840
} |
FStar.Pervasives.Lemma | val valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ valid p h2 s2 pos2 /\ k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2))
(ensures
(let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2' | val valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ valid p h2 s2 pos2 /\ k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2))
(ensures
(let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ valid p h2 s2 pos2 /\ k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2))
(ensures
(let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) = | false | null | true | let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_exact_ext_elim",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_valid_exact",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"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.contents",
"Prims.squash",
"Prims.int",
"Prims.op_Subtraction",
"FStar.UInt32.v",
"LowParse.Bytes.bytes",
"LowParse.Low.Base.Spec.bytes_of_slice_from_to",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires
(valid p h1 s1 pos1 /\ valid p h2 s2 pos2 /\ k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2))
(ensures
(let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2')) | [] | LowParse.Low.Base.Spec.valid_ext_elim | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h1: FStar.Monotonic.HyperStack.mem ->
s1: LowParse.Slice.slice rrel1 rel1 ->
pos1: FStar.UInt32.t ->
h2: FStar.Monotonic.HyperStack.mem ->
s2: LowParse.Slice.slice rrel2 rel2 ->
pos2: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid p h1 s1 pos1 /\ LowParse.Low.Base.Spec.valid p h2 s2 pos2 /\
Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.contents p h1 s1 pos1 == LowParse.Low.Base.Spec.contents p h2 s2 pos2
)
(ensures
(let pos1' = LowParse.Low.Base.Spec.get_valid_pos p h1 s1 pos1 in
let pos2' = LowParse.Low.Base.Spec.get_valid_pos p h2 s2 pos2 in
FStar.UInt32.v pos2' - FStar.UInt32.v pos2 == FStar.UInt32.v pos1' - FStar.UInt32.v pos1 /\
LowParse.Low.Base.Spec.bytes_of_slice_from_to h1 s1 pos1 pos1' ==
LowParse.Low.Base.Spec.bytes_of_slice_from_to h2 s2 pos2 pos2')) | {
"end_col": 58,
"end_line": 937,
"start_col": 1,
"start_line": 933
} |
FStar.Pervasives.Lemma | val gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl': bytes)
: Lemma
(requires
(k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl')) (ensures (gaccessor_pre p1 p2 cl sl')) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl' | val gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl': bytes)
: Lemma
(requires
(k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl')) (ensures (gaccessor_pre p1 p2 cl sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl': bytes)
: Lemma
(requires
(k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl')) (ensures (gaccessor_pre p1 p2 cl sl')) = | false | null | true | parse_strong_prefix p1 sl sl' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor'",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.parse_strong_prefix",
"Prims.unit",
"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.squash",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl': bytes)
: Lemma
(requires
(k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl')) (ensures (gaccessor_pre p1 p2 cl sl')) | [] | LowParse.Low.Base.Spec.gaccessor_no_lookahead_weaken | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
f: LowParse.Low.Base.Spec.gaccessor' p1 p2 cl ->
sl: LowParse.Bytes.bytes ->
sl': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.gaccessor_pre p1 p2 cl sl /\
LowParse.Spec.Base.no_lookahead_on_precond p1 sl sl')
(ensures LowParse.Low.Base.Spec.gaccessor_pre p1 p2 cl sl') | {
"end_col": 31,
"end_line": 1270,
"start_col": 2,
"start_line": 1270
} |
Prims.Ghost | val slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t (requires (valid p1 h sl pos)) (ensures (fun pos' -> True)) | [
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small) | val slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t (requires (valid p1 h sl pos)) (ensures (fun pos' -> True))
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t (requires (valid p1 h sl pos)) (ensures (fun pos' -> True)) = | false | null | false | let small = bytes_of_slice_from h sl pos in
pos `U32.add` (U32.uint_to_t (g small)) | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.UInt32.add",
"FStar.UInt32.uint_to_t",
"LowParse.Bytes.bytes",
"LowParse.Slice.bytes_of_slice_from",
"LowParse.Low.Base.Spec.valid",
"Prims.l_True"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t (requires (valid p1 h sl pos)) (ensures (fun pos' -> True)) | [] | LowParse.Low.Base.Spec.slice_access' | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h: FStar.Monotonic.HyperStack.mem ->
g: LowParse.Low.Base.Spec.gaccessor p1 p2 cl ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t
-> Prims.Ghost FStar.UInt32.t | {
"end_col": 39,
"end_line": 1698,
"start_col": 1,
"start_line": 1696
} |
FStar.Pervasives.Lemma | val valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (pos <> pos' /\ valid_list p h sl pos pos'))
(ensures
(pos <> pos' /\ valid_list p h sl pos pos' /\ valid p h sl pos /\
(let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'))
) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
pos <> pos' /\
valid_list p h sl pos pos'
))
(ensures (
pos <> pos' /\
valid_list p h sl pos pos' /\
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'
)))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos' | val valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (pos <> pos' /\ valid_list p h sl pos pos'))
(ensures
(pos <> pos' /\ valid_list p h sl pos pos' /\ valid p h sl pos /\
(let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'))
)
let valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (pos <> pos' /\ valid_list p h sl pos pos'))
(ensures
(pos <> pos' /\ valid_list p h sl pos pos' /\ valid p h sl pos /\
(let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'))
) = | false | null | true | valid_list_equiv p h sl pos pos';
contents_list_eq p h sl pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.contents_list_eq",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list_equiv",
"Prims.l_and",
"Prims.b2t",
"Prims.op_disEquality",
"LowParse.Low.Base.Spec.valid_list",
"Prims.squash",
"LowParse.Low.Base.Spec.valid",
"Prims.eq2",
"Prims.list",
"LowParse.Low.Base.Spec.contents_list",
"Prims.Cons",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos'
val contents_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost (list t)
(requires (valid_list p h sl pos pos'))
(ensures (fun _ -> True))
(decreases (U32.v pos' - U32.v pos))
val contents_list_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (contents_list p h sl pos pos' == (
valid_list_equiv p h sl pos pos';
if pos = pos'
then []
else
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
)))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == []
))
= valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos
let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos'
))
(ensures (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
module L = FStar.List.Tot
let valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
pos <> pos' /\
valid_list p h sl pos pos'
))
(ensures (
pos <> pos' /\
valid_list p h sl pos pos' /\
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos' | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos pos': U32.t)
: Lemma (requires (pos <> pos' /\ valid_list p h sl pos pos'))
(ensures
(pos <> pos' /\ valid_list p h sl pos pos' /\ valid p h sl pos /\
(let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'))
) | [] | LowParse.Low.Base.Spec.valid_list_cons_recip | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires pos <> pos' /\ LowParse.Low.Base.Spec.valid_list p h sl pos pos')
(ensures
pos <> pos' /\ LowParse.Low.Base.Spec.valid_list p h sl pos pos' /\
LowParse.Low.Base.Spec.valid p h sl pos /\
(let pos1 = LowParse.Low.Base.Spec.get_valid_pos p h sl pos in
LowParse.Low.Base.Spec.valid_list p h sl pos1 pos' /\
LowParse.Low.Base.Spec.contents_list p h sl pos pos' ==
LowParse.Low.Base.Spec.contents p h sl pos ::
LowParse.Low.Base.Spec.contents_list p h sl pos1 pos')) | {
"end_col": 34,
"end_line": 2005,
"start_col": 2,
"start_line": 2004
} |
FStar.Pervasives.Lemma | val valid_list_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_list p h s pos pos' \/ valid_list p h' s pos pos') ==>
(valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_list p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h' s pos pos'); SMTPat (B.modifies l h h')]
]
] | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_list_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_list p h s pos pos' \/ valid_list p h' s pos pos') ==> (
valid_list p h s pos pos' /\
valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_list p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= Classical.move_requires (valid_list_frame_1 p h s pos pos' l) h';
Classical.move_requires (valid_list_frame_2 p h s pos pos' l) h' | val valid_list_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_list p h s pos pos' \/ valid_list p h' s pos pos') ==>
(valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_list p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h' s pos pos'); SMTPat (B.modifies l h h')]
]
]
let valid_list_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_list p h s pos pos' \/ valid_list p h' s pos pos') ==>
(valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_list p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h' s pos pos'); SMTPat (B.modifies l h h')]
]
] = | false | null | true | Classical.move_requires (valid_list_frame_1 p h s pos pos' l) h';
Classical.move_requires (valid_list_frame_2 p h s pos pos' l) h' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"FStar.Classical.move_requires",
"Prims.l_and",
"LowParse.Slice.live_slice",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.valid_list",
"Prims.eq2",
"Prims.list",
"LowParse.Low.Base.Spec.contents_list",
"LowParse.Low.Base.Spec.valid_list_frame_2",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list_frame_1",
"Prims.squash",
"Prims.l_imp",
"Prims.l_or",
"Prims.Cons",
"FStar.Pervasives.pattern",
"FStar.Pervasives.smt_pat_or",
"FStar.Pervasives.smt_pat",
"Prims.Nil"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos'
val contents_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost (list t)
(requires (valid_list p h sl pos pos'))
(ensures (fun _ -> True))
(decreases (U32.v pos' - U32.v pos))
val contents_list_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (contents_list p h sl pos pos' == (
valid_list_equiv p h sl pos pos';
if pos = pos'
then []
else
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
)))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == []
))
= valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos
let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos'
))
(ensures (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
module L = FStar.List.Tot
let valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
pos <> pos' /\
valid_list p h sl pos pos'
))
(ensures (
pos <> pos' /\
valid_list p h sl pos pos' /\
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'
)))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
let rec valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h s pos pos'))
(ensures (
valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h s pos pos';
contents_list_eq p h s pos pos' ;
valid_list_equiv p h' s pos pos' ;
begin if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h s pos in
valid_list_frame_1 p h s pos1 pos' l h'
end end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h' s pos pos'
let rec valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h' s pos pos'))
(ensures (
valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h' s pos pos' ;
contents_list_eq p h' s pos pos' ;
valid_list_equiv p h s pos pos' ;
if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h' s pos in
valid_valid_exact p h' s pos;
valid_exact_valid p h s pos pos1;
valid_list_frame_2 p h s pos1 pos' l h'
end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h s pos pos'
let valid_list_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_list p h s pos pos' \/ valid_list p h' s pos pos') ==> (
valid_list p h s pos pos' /\
valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_list p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h' s pos pos'); SMTPat (B.modifies l h h')]; | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_list_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures
((valid_list p h s pos pos' \/ valid_list p h' s pos pos') ==>
(valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos')))
[
SMTPatOr
[
[SMTPat (valid_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_list p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h' s pos pos'); SMTPat (B.modifies l h h')]
]
] | [] | LowParse.Low.Base.Spec.valid_list_frame | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h s /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l (LowParse.Slice.loc_slice_from_to s pos pos'))
(ensures
LowParse.Low.Base.Spec.valid_list p h s pos pos' \/
LowParse.Low.Base.Spec.valid_list p h' s pos pos' ==>
LowParse.Low.Base.Spec.valid_list p h s pos pos' /\
LowParse.Low.Base.Spec.valid_list p h' s pos pos' /\
LowParse.Low.Base.Spec.contents_list p h' s pos pos' ==
LowParse.Low.Base.Spec.contents_list p h s pos pos')
[
SMTPatOr [
[
SMTPat (LowParse.Low.Base.Spec.valid_list p h s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.valid_list p h' s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents_list p h s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
];
[
SMTPat (LowParse.Low.Base.Spec.contents_list p h' s pos pos');
SMTPat (LowStar.Monotonic.Buffer.modifies l h h')
]
]
] | {
"end_col": 66,
"end_line": 2092,
"start_col": 2,
"start_line": 2091
} |
FStar.Pervasives.Lemma | val valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\
valid_list p h' s pos pos'))
(ensures
(valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos'))
(decreases (U32.v pos' - U32.v pos)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h' s pos pos'))
(ensures (
valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h' s pos pos' ;
contents_list_eq p h' s pos pos' ;
valid_list_equiv p h s pos pos' ;
if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h' s pos in
valid_valid_exact p h' s pos;
valid_exact_valid p h s pos pos1;
valid_list_frame_2 p h s pos1 pos' l h'
end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h s pos pos' | val valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\
valid_list p h' s pos pos'))
(ensures
(valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos'))
(decreases (U32.v pos' - U32.v pos))
let rec valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\
valid_list p h' s pos pos'))
(ensures
(valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos'))
(decreases (U32.v pos' - U32.v pos)) = | false | null | true | valid_list_equiv p h' s pos pos';
contents_list_eq p h' s pos pos';
valid_list_equiv p h s pos pos';
if pos = pos'
then ()
else
(let pos1 = get_valid_pos p h' s pos in
valid_valid_exact p h' s pos;
valid_exact_valid p h s pos pos1;
valid_list_frame_2 p h s pos1 pos' l h');
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h s pos pos' | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma",
""
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowStar.Monotonic.Buffer.loc",
"LowParse.Low.Base.Spec.contents_list_eq",
"Prims.unit",
"LowStar.Monotonic.Buffer.modifies_buffer_from_to_elim",
"LowParse.Slice.buffer_srel_of_srel",
"LowParse.Slice.__proj__Mkslice__item__base",
"Prims.op_Equality",
"Prims.bool",
"LowParse.Low.Base.Spec.valid_list_frame_2",
"LowParse.Low.Base.Spec.valid_exact_valid",
"LowParse.Low.Base.Spec.valid_valid_exact",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Low.Base.Spec.valid_list_equiv",
"Prims.l_and",
"LowParse.Slice.live_slice",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.valid_list",
"Prims.squash",
"Prims.eq2",
"Prims.list",
"LowParse.Low.Base.Spec.contents_list",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos'
val contents_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost (list t)
(requires (valid_list p h sl pos pos'))
(ensures (fun _ -> True))
(decreases (U32.v pos' - U32.v pos))
val contents_list_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (contents_list p h sl pos pos' == (
valid_list_equiv p h sl pos pos';
if pos = pos'
then []
else
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
)))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == []
))
= valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos
let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos'
))
(ensures (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
module L = FStar.List.Tot
let valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
pos <> pos' /\
valid_list p h sl pos pos'
))
(ensures (
pos <> pos' /\
valid_list p h sl pos pos' /\
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'
)))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
let rec valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h s pos pos'))
(ensures (
valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h s pos pos';
contents_list_eq p h s pos pos' ;
valid_list_equiv p h' s pos pos' ;
begin if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h s pos in
valid_list_frame_1 p h s pos1 pos' l h'
end end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h' s pos pos'
let rec valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h' s pos pos'))
(ensures (
valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
)) | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos pos': U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires
(live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\
valid_list p h' s pos pos'))
(ensures
(valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\
contents_list p h' s pos pos' == contents_list p h s pos pos'))
(decreases (U32.v pos' - U32.v pos)) | [
"recursion"
] | LowParse.Low.Base.Spec.valid_list_frame_2 | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
s: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
l: LowStar.Monotonic.Buffer.loc ->
h': FStar.Monotonic.HyperStack.mem
-> FStar.Pervasives.Lemma
(requires
LowParse.Slice.live_slice h s /\ LowStar.Monotonic.Buffer.modifies l h h' /\
LowStar.Monotonic.Buffer.loc_disjoint l (LowParse.Slice.loc_slice_from_to s pos pos') /\
LowParse.Low.Base.Spec.valid_list p h' s pos pos')
(ensures
LowParse.Low.Base.Spec.valid_list p h' s pos pos' /\
LowParse.Low.Base.Spec.valid_list p h s pos pos' /\
LowParse.Low.Base.Spec.contents_list p h' s pos pos' ==
LowParse.Low.Base.Spec.contents_list p h s pos pos')
(decreases FStar.UInt32.v pos' - FStar.UInt32.v pos) | {
"end_col": 33,
"end_line": 2065,
"start_col": 2,
"start_line": 2053
} |
FStar.Pervasives.Lemma | val valid_list_snoc
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2: U32.t)
: Lemma (requires (valid_list p h sl pos1 pos2 /\ valid p h sl pos2))
(ensures
(let pos3 = get_valid_pos p h sl pos2 in
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 ==
(contents_list p h sl pos1 pos2)
`L.append`
[contents p h sl pos2])) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"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.Monotonic.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "LowParse.Slice",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_list_snoc
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 : U32.t)
: Lemma
(requires (
valid_list p h sl pos1 pos2 /\
valid p h sl pos2
))
(ensures (
let pos3 = get_valid_pos p h sl pos2 in
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 == contents_list p h sl pos1 pos2 `L.append` [contents p h sl pos2]
))
= let pos3 = get_valid_pos p h sl pos2 in
valid_list_nil p h sl pos3;
valid_list_cons p h sl pos2 pos3;
valid_list_append p h sl pos1 pos2 pos3 | val valid_list_snoc
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2: U32.t)
: Lemma (requires (valid_list p h sl pos1 pos2 /\ valid p h sl pos2))
(ensures
(let pos3 = get_valid_pos p h sl pos2 in
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 ==
(contents_list p h sl pos1 pos2)
`L.append`
[contents p h sl pos2]))
let valid_list_snoc
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2: U32.t)
: Lemma (requires (valid_list p h sl pos1 pos2 /\ valid p h sl pos2))
(ensures
(let pos3 = get_valid_pos p h sl pos2 in
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 ==
(contents_list p h sl pos1 pos2)
`L.append`
[contents p h sl pos2])) = | false | null | true | let pos3 = get_valid_pos p h sl pos2 in
valid_list_nil p h sl pos3;
valid_list_cons p h sl pos2 pos3;
valid_list_append p h sl pos1 pos2 pos3 | {
"checked_file": "LowParse.Low.Base.Spec.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Monotonic.Buffer.fsti.checked",
"LowParse.Spec.Base.fsti.checked",
"LowParse.Slice.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Base.Spec.fsti"
} | [
"lemma"
] | [
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Low.Base.Spec.valid_list_append",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list_cons",
"LowParse.Low.Base.Spec.valid_list_nil",
"LowParse.Low.Base.Spec.get_valid_pos",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid_list",
"LowParse.Low.Base.Spec.valid",
"Prims.squash",
"Prims.eq2",
"Prims.list",
"LowParse.Low.Base.Spec.contents_list",
"FStar.List.Tot.Base.append",
"Prims.Cons",
"LowParse.Low.Base.Spec.contents",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Low.Base.Spec
include LowParse.Spec.Base
include LowParse.Slice
module M = LowParse.Math
module B = LowStar.Monotonic.Buffer
module U32 = FStar.UInt32
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module Seq = FStar.Seq
let valid'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
= U32.v pos <= U32.v s.len /\
live_slice h s /\
Some? (parse p (bytes_of_slice_from h s pos))
val valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: GTot Type0
val valid_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(valid p h s pos <==> valid' p h s pos)
val valid_dec
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost bool
(requires (live_slice h s))
(ensures (fun b ->
b == true <==> valid p h s pos
))
let valid_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid' p h s pos))
// [SMTPat (valid p h s pos)]
= valid_equiv p h s pos
let valid_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (U32.v pos + k.parser_kind_low <= U32.v s.len /\
live_slice h s))
[SMTPat (valid p h s pos)]
= parser_kind_prop_equiv k p;
valid_equiv p h s pos
let contents'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid' p h s pos))
(ensures (fun _ -> True))
= let Some (v, _) = parse p (bytes_of_slice_from h s pos) in
v
val contents
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Ghost t
(requires (valid p h s pos))
(ensures (fun _ -> True))
val contents_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos))
(ensures (valid p h s pos /\ valid' p h s pos /\ contents p h s pos == contents' p h s pos))
let content_length'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid' p h sl pos))
(ensures (fun res ->
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
= let Some (_, consumed) = parse p (bytes_of_slice_from h sl pos) in
parser_kind_prop_equiv k p;
consumed
val content_length
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost nat
(requires (valid p h sl pos))
(ensures (fun res -> True))
val serialized_length
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Ghost nat
(requires True)
(ensures (fun res ->
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
val serialized_length_eq
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: Lemma
(serialized_length s x == Seq.length (serialize s x))
val content_length_eq_gen
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (valid p h sl pos /\ valid' p h sl pos /\ content_length p h sl pos == content_length' p h sl pos))
let content_length_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let res = content_length p h sl pos in
U32.v pos + res <= U32.v sl.len /\
k.parser_kind_low <= res /\ (
match k.parser_kind_high with
| None -> True
| Some max -> res <= max
)))
[SMTPat (content_length p h sl pos)]
= content_length_eq_gen p h sl pos
let valid_facts
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
((valid p h sl pos <==> valid' p h sl pos) /\
(valid p h sl pos ==> (
contents p h sl pos == contents' p h sl pos /\
content_length p h sl pos == content_length' p h sl pos
)))
= valid_equiv p h sl pos;
Classical.move_requires (contents_eq p h sl) pos;
Classical.move_requires (content_length_eq_gen p h sl) pos
val content_length_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (content_length p h sl pos == serialized_length s (contents p h sl pos)))
[SMTPat (serialized_length s (contents p h sl pos))]
let valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
= valid p h sl pos /\
U32.v pos + content_length p h sl pos == U32.v pos'
val get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (valid p h sl pos))
(ensures (fun pos' -> True))
val get_valid_pos_post
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h sl pos))
(ensures (
let pos' = get_valid_pos p h sl pos in
valid_pos p h sl pos pos'
))
[SMTPat (get_valid_pos p h sl pos)]
let valid_pos_get_valid_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h sl pos pos'))
(ensures (get_valid_pos p h sl pos == pos'))
[SMTPat (valid_pos p h sl pos pos'); SMTPat (get_valid_pos p h sl pos)]
= ()
let valid_pos_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p h sl pos /\
k.parser_kind_subkind == Some ParserConsumesAll
))
(ensures (
valid_pos p h sl pos sl.len
))
= parser_kind_prop_equiv k p;
valid_facts p h sl pos
let valid_content
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
= valid p h sl pos /\
contents p h sl pos == x
let valid_content_pos
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(x: t)
(pos' : U32.t)
= valid_pos p h sl pos pos' /\
valid_content p h sl pos x
let valid_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (live_slice h sl /\ B.modifies l h h' /\ B.loc_disjoint (loc_slice_from sl pos) l))
(ensures (
(valid p h sl pos \/ valid p h' sl pos) ==> (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
)))
[SMTPatOr [
[SMTPat (valid p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (U32.v pos <= U32.v sl.len /\ (valid p h sl pos \/ valid p h' sl pos)))
(ensures (
valid p h sl pos /\
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
=
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h';
valid_facts p h sl pos;
valid_facts p h' sl pos
in
Classical.move_requires f ()
(* Case where we do not have the strong prefix property (e.g. lists): we need an extra length *)
let bytes_of_slice_from_to (#rrel #rel: _)
(h: HS.mem) (s: slice rrel rel) (pos pos': U32.t) : Ghost bytes (requires (U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len)) (ensures (fun _ -> True)) =
Seq.slice (B.as_seq h s.base) (U32.v pos) (U32.v pos')
let valid_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
= U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\
live_slice h s /\ (
let len' = pos' `U32.sub` pos in
match parse p (bytes_of_slice_from_to h s pos pos') with
| None -> False
| Some (_, consumed) -> (consumed <: nat) == U32.v len'
)
val valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
val valid_exact_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_exact p h s pos pos' <==> valid_exact' p h s pos pos')
let valid_exact_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact' p h s pos pos'))
// [SMTPat (valid_exact p h s pos pos')]
= valid_exact_equiv p h s pos pos'
let valid_exact_elim'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (
live_slice h s /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v s.len /\ (
let length = U32.v pos' - U32.v pos in
k.parser_kind_low <= length /\ (
match k.parser_kind_high with
| Some high -> length <= high
| _ -> True
))))
[SMTPat (valid_exact p h s pos pos')]
= parser_kind_prop_equiv k p;
valid_exact_equiv p h s pos pos'
let contents_exact'
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact' p h s pos pos'))
(ensures (fun _ -> True))
= let (Some (v, _)) = parse p (bytes_of_slice_from_to h s pos pos') in
v
val contents_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost t
(requires (valid_exact p h s pos pos'))
(ensures (fun _ -> True))
val contents_exact_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos'))
(ensures (valid_exact p h s pos pos' /\ valid_exact' p h s pos pos' /\ contents_exact p h s pos pos' == contents_exact' p h s pos pos'))
let valid_exact_serialize
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h sl pos pos'))
(ensures (
serialize s (contents_exact p h sl pos pos') == bytes_of_slice_from_to h sl pos pos'
))
= valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos' ;
serializer_correct_implies_complete p s;
()
let serialize_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(h: HS.mem)
(sl: slice rrel rel)
(x: t)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (
live_slice h sl /\
U32.v pos + Seq.length (serialize s x) == U32.v pos' /\
U32.v pos' <= U32.v sl.len /\
bytes_of_slice_from_to h sl pos pos' `Seq.equal` serialize s x
))
(ensures (
valid_exact p h sl pos pos' /\
contents_exact p h sl pos pos' == x
))
= serializer_correct_implies_complete p s;
valid_exact_equiv p h sl pos pos' ;
contents_exact_eq p h sl pos pos'
let valid_exact_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_exact p h s pos pos' \/ valid_exact p h' s pos pos') ==> (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_exact p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= let f () : Lemma
(requires (
U32.v pos <= U32.v pos' /\ U32.v pos' <= U32.v s.len /\ (valid_exact p h s pos pos' \/ valid_exact p h' s pos pos')
))
(ensures (
valid_exact p h s pos pos' /\
valid_exact p h' s pos pos' /\ contents_exact p h' s pos pos' == contents_exact p h s pos pos'
))
=
valid_exact_equiv p h s pos pos' ;
valid_exact_equiv p h' s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
Classical.move_requires (contents_exact_eq p h' s pos) pos' ;
B.modifies_buffer_from_to_elim s.base pos pos' l h h'
in
Classical.move_requires f ()
let valid_valid_exact_consumes_all
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (k.parser_kind_subkind == Some ParserConsumesAll))
(ensures (
(valid p h s pos \/ valid_exact p h s pos s.len) ==>
(valid_exact p h s pos s.len /\
valid_content_pos p h s pos (contents_exact p h s pos s.len) s.len)
))
= parser_kind_prop_equiv k p;
valid_facts p h s pos;
valid_exact_equiv p h s pos s.len;
Classical.move_requires (contents_exact_eq p h s pos) s.len
let valid_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (valid p h s pos /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
let npos' = U32.v pos + content_length p h s pos in
npos' <= U32.v s.len /\ (
let pos' = U32.uint_to_t npos' in
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
)))
= valid_facts p h s pos;
let npos' = U32.v pos + content_length p h s pos in
let pos' = U32.uint_to_t npos' in
valid_exact_equiv p h s pos pos' ;
Classical.move_requires (contents_exact_eq p h s pos) pos' ;
parse_strong_prefix p (bytes_of_slice_from h s pos) (bytes_of_slice_from_to h s pos pos')
let valid_pos_valid_exact
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
= valid_valid_exact p h s pos
let valid_pos_valid_exact_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_pos p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_exact p h s pos pos' /\
contents_exact p h s pos pos' == contents p h s pos
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_pos_valid_exact p h s pos pos'
let valid_exact_valid
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
= valid_exact_equiv p h s pos pos' ;
contents_exact_eq p h s pos pos' ;
valid_facts p h s pos;
parse_strong_prefix p (bytes_of_slice_from_to h s pos pos') (bytes_of_slice_from h s pos)
let valid_exact_valid_pat
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_exact p h s pos pos' /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h s pos (contents_exact p h s pos pos') pos'
))
[SMTPat (valid_exact p h s pos pos'); SMTPat (valid p h s pos)]
= valid_exact_valid p h s pos pos'
let valid_pos_frame_strong_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
valid_pos p h sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
))
= valid_pos_valid_exact p h sl pos pos';
valid_exact_valid p h' sl pos pos'
let valid_pos_frame_strong_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid_pos p h' sl pos pos' /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_pos p h sl pos pos' /\
valid_pos p h' sl pos pos' /\
valid_content_pos p h sl pos (contents p h' sl pos) pos'
))
= valid_pos_valid_exact p h' sl pos pos';
valid_exact_valid p h sl pos pos'
let valid_pos_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos pos') l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
(valid_pos p h sl pos pos' \/ valid_pos p h' sl pos pos') ==> (
valid_pos p h sl pos pos' /\
valid_content_pos p h' sl pos (contents p h sl pos) pos'
)))
= Classical.move_requires (valid_pos_frame_strong_1 p h sl pos pos' l) h';
Classical.move_requires (valid_pos_frame_strong_2 p h sl pos pos' l) h'
let valid_frame_strong
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h': HS.mem)
: Lemma
(requires (
live_slice h sl /\
valid p h sl pos /\
B.modifies l h h' /\ B.loc_disjoint (loc_slice_from_to sl pos (get_valid_pos p h sl pos)) l /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_content_pos p h' sl pos (contents p h sl pos) (get_valid_pos p h sl pos)
))
[SMTPatOr [
// [SMTPat (valid p h sl pos); SMTPat (B.modifies_inert l h h')];
[SMTPat (valid p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (contents p h' sl pos); SMTPat (B.modifies l h h')];
[SMTPat (content_length p h' sl pos); SMTPat (B.modifies l h h')];
]]
= valid_pos_frame_strong p h sl pos (get_valid_pos p h sl pos) l h'
let valid_exact_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
live_slice h2 s2 /\
U32.v pos1' - U32.v pos1 == U32.v pos2' - U32.v pos2 /\
U32.v pos2' <= U32.v s2.len /\
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))
(ensures (
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h2 s2 pos2 pos2' == contents_exact p h1 s1 pos1 pos1'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2'
let valid_exact_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(pos1' : U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
(pos2' : U32.t)
: Lemma
(requires (
valid_exact p h1 s1 pos1 pos1' /\
valid_exact p h2 s2 pos2 pos2' /\
contents_exact p h1 s1 pos1 pos1' == contents_exact p h2 s2 pos2 pos2'
))
(ensures (
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= valid_exact_equiv p h1 s1 pos1 pos1' ;
valid_exact_equiv p h2 s2 pos2 pos2' ;
contents_exact_eq p h1 s1 pos1 pos1' ;
contents_exact_eq p h2 s2 pos2 pos2' ;
parser_kind_prop_equiv k p;
assert (injective_precond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'));
assert (injective_postcond p (bytes_of_slice_from_to h1 s1 pos1 pos1') (bytes_of_slice_from_to h2 s2 pos2 pos2'))
let valid_ext_intro
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
k.parser_kind_subkind == Some ParserStrong /\ (
let pos1' = get_valid_pos p h1 s1 pos1 in
live_slice h2 s2 /\
U32.v pos2 + (U32.v pos1' - U32.v pos1) <= U32.v s2.len /\ (
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
bytes_of_slice_from_to h1 s1 pos1 pos1' `Seq.equal` bytes_of_slice_from_to h2 s2 pos2 pos2'
))))
(ensures (
valid_content_pos p h2 s2 pos2 (contents p h1 s1 pos1) (pos2 `U32.add` (get_valid_pos p h1 s1 pos1 `U32.sub` pos1))
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = pos2 `U32.add` (pos1' `U32.sub` pos1) in
valid_pos_valid_exact p h1 s1 pos1 pos1' ;
valid_exact_ext_intro p h1 s1 pos1 pos1' h2 s2 pos2 pos2' ;
valid_exact_valid p h2 s2 pos2 pos2'
let valid_ext_elim
(#rrel1 #rel1: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h1: HS.mem)
(s1: slice rrel1 rel1)
(pos1: U32.t)
(h2: HS.mem)
(#rrel2 #rel2: _)
(s2: slice rrel2 rel2)
(pos2: U32.t)
: Lemma
(requires (
valid p h1 s1 pos1 /\
valid p h2 s2 pos2 /\
k.parser_kind_subkind == Some ParserStrong /\
contents p h1 s1 pos1 == contents p h2 s2 pos2
))
(ensures (
let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
U32.v pos2' - U32.v pos2 == U32.v pos1' - U32.v pos1 /\
bytes_of_slice_from_to h1 s1 pos1 pos1' == bytes_of_slice_from_to h2 s2 pos2 pos2'
))
= let pos1' = get_valid_pos p h1 s1 pos1 in
let pos2' = get_valid_pos p h2 s2 pos2 in
valid_valid_exact p h1 s1 pos1;
valid_valid_exact p h2 s2 pos2;
valid_exact_ext_elim p h1 s1 pos1 pos1' h2 s2 pos2 pos2'
(* Accessors for reading only (no in-place serialization yet) *)
noeq
type clens (t1: Type) (t2: Type) = {
clens_cond: t1 -> GTot Type0;
clens_get: (x1: t1) -> Ghost t2 (requires (clens_cond x1)) (ensures (fun _ -> True));
(*
clens_put: (x1: t1) -> t2 -> Ghost t1 (requires (clens_cond x1)) (ensures (fun x1' -> clens_cond x1'));
clens_get_put: (x1: t1) -> (x2: t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_get (clens_put x1 x2) == x2));
clens_put_put: (x1: t1) -> (x2: t2) -> (x2' : t2) -> Lemma (requires (clens_cond x1)) (ensures (clens_put (clens_put x1 x2) x2' == clens_put x1 x2'));
clens_put_get: (x1: t1) -> Lemma (requires (clens_cond x1)) (ensures (clens_put x1 (clens_get x1) == x1));
*)
}
let clens_id (t: Type) : Tot (clens t t) = {
clens_cond = (fun _ -> True);
clens_get = (fun x -> x);
}
let clens_eq (#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t') : GTot Type0 =
(forall (x: t) . {:pattern (cl1.clens_cond x) \/ (cl2.clens_cond x)} cl1.clens_cond x <==> cl2.clens_cond x) /\
(forall (x: t) . {:pattern (cl1.clens_get x) \/ (cl2.clens_get x)} (cl1.clens_cond x \/ cl2.clens_cond x) ==> (cl1.clens_get x == cl2.clens_get x))
let clens_eq_intro
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Lemma
(cl1.clens_cond x <==> cl2.clens_cond x)
))
(get: (
(x: t) ->
Lemma
(requires (cl1.clens_cond x /\ cl2.clens_cond x))
(ensures (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Lemma
(clens_eq cl1 cl2)
= Classical.forall_intro cond;
Classical.forall_intro (Classical.move_requires get)
let clens_eq_intro'
(#t: Type) (#t': Type) (cl1: clens t t') (cl2: clens t t')
(cond: (
(x: t) ->
Tot (squash (cl1.clens_cond x <==> cl2.clens_cond x))
))
(get: (
(x: t) ->
(sq: squash (cl1.clens_cond x /\ cl2.clens_cond x)) ->
Tot (squash (cl1.clens_cond x /\ cl2.clens_cond x /\ cl1.clens_get x == cl2.clens_get x))
))
: Tot (squash (clens_eq cl1 cl2))
= clens_eq_intro cl1 cl2 (fun x -> cond x) (fun x -> get x ())
(*
let clens_get_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_get (l.clens_put x1 x2) == x2))
[SMTPat (l.clens_get (l.clens_put x1 x2))]
= l.clens_get_put x1 x2
let clens_put_put'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1) (x2: t2) (x2' : t2)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put (l.clens_put x1 x2) x2' == l.clens_put x1 x2'))
[SMTPat (l.clens_put (l.clens_put x1 x2) x2')]
= l.clens_put_put x1 x2 x2'
let clens_put_get'
(#t1: Type) (#clens_cond: t1 -> GTot Type0) (#t2: Type) (l: clens clens_cond t2)
(x1: t1)
: Lemma
(requires (clens_cond x1))
(ensures (l.clens_put x1 (l.clens_get x1) == x1))
[SMTPat (l.clens_put x1 (l.clens_get x1))]
= l.clens_put_get x1
abstract
let clens_disjoint_l
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= (forall (x0: t0) (x2: t2) . (clens_cond2 x0 /\ clens_cond3 x0) ==>
(let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
abstract
let clens_disjoint_l_elim
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(x0: t0) (x2: t2)
: Lemma
(requires (clens_disjoint_l l2 l3 /\ clens_cond2 x0 /\ clens_cond3 x0))
(ensures (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))
[SMTPat (l3.clens_get (l2.clens_put x0 x2))]
= ()
abstract
let clens_disjoint_l_intro
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(lem: (
(x0: t0) ->
(x2: t2) ->
Lemma
(requires (clens_cond2 x0 /\ clens_cond3 x0))
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0)))
))
: Lemma
(clens_disjoint_l l2 l3)
= let lem'
(x0: t0)
(x2: t2)
: Lemma
((clens_cond2 x0 /\ clens_cond3 x0) ==>
(ensures (clens_cond2 x0 /\ clens_cond3 x0 /\ (let x0' = l2.clens_put x0 x2 in clens_cond3 x0' /\ l3.clens_get x0' == l3.clens_get x0))))
= Classical.move_requires (lem x0) x2
in
Classical.forall_intro_2 lem'
let clens_disjoint
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: GTot Type0
= clens_disjoint_l l2 l3 /\ clens_disjoint_l l3 l2
let clens_disjoint_sym
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
: Lemma
(clens_disjoint l2 l3 <==> clens_disjoint l3 l2)
[SMTPat (clens_disjoint l2 l3)]
= ()
*)
let clens_compose_cond
(#t1: Type)
(#t2: Type)
(l12: clens t1 t2)
(clens_cond2: t2 -> GTot Type0)
(x1: t1)
: GTot Type0
= l12.clens_cond x1 /\
clens_cond2 (l12.clens_get x1)
let clens_compose
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: Tot (clens t1 t3)
= {
clens_cond = (clens_compose_cond l12 l23.clens_cond);
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
(*
clens_put = (fun x1 x3 ->
let x2' = l23.clens_put (l12.clens_get x1) x3 in
let x1' = l12.clens_put x1 x2' in
x1'
);
clens_get_put = (fun x1 x3 -> ());
clens_put_put = (fun x1 x3 x3' -> ());
clens_put_get = (fun x1 -> ());
*)
}
let clens_compose_strong_pre
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3)
: GTot Type0
= forall (x: t1) . {:pattern (l12.clens_cond x) \/ (l23.clens_cond (l12.clens_get x))} l12.clens_cond x ==> l23.clens_cond (l12.clens_get x)
let clens_compose_strong
(#t1: Type)
(#t2: Type)
(#t3: Type)
(l12: clens t1 t2)
(l23: clens t2 t3 { clens_compose_strong_pre l12 l23 })
: Tot (clens t1 t3)
= {
clens_cond = l12.clens_cond;
clens_get = (fun x1 -> l23.clens_get (l12.clens_get x1));
}
(*
abstract
let clens_disjoint_compose
(#t0: Type)
(#clens_cond2: t0 -> GTot Type0)
(#clens_cond3: t0 -> GTot Type0)
(#t2 #t3: Type)
(l2: clens clens_cond2 t2)
(l3: clens clens_cond3 t3)
(#clens_cond3': t3 -> GTot Type0)
(#t3' : Type)
(l3' : clens clens_cond3' t3')
: Lemma
(requires (clens_disjoint l2 l3))
(ensures (clens_disjoint l2 (clens_compose l3 l3')))
[SMTPat (clens_disjoint l2 (clens_compose l3 l3'))]
= ()
*)
let gaccessor_pre
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
: GTot Type0
= match parse p1 sl with
| Some (x1, _) -> cl.clens_cond x1
| _ -> False
let gaccessor_post
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl: bytes)
(res : nat)
: GTot Type0
= res <= Seq.length sl /\
begin match parse p1 sl with
| Some (x1, consumed1) ->
begin match parse p2 (Seq.slice sl res (Seq.length sl)) with
| Some (x2, consumed2) ->
cl.clens_cond x1 /\
x2 == cl.clens_get x1 /\
res + consumed2 <= consumed1
| _ -> False
end
| _ -> False
end
let gaccessor_post'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(sl : bytes)
(res: nat)
: GTot Type0
=
res <= Seq.length sl /\
(gaccessor_pre p1 p2 cl sl ==> gaccessor_post p1 p2 cl sl res)
let gaccessor'
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (sl: bytes) ->
Ghost (nat)
(requires True)
(ensures (fun res ->
gaccessor_post' p1 p2 cl sl res
))
let gaccessor_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (k1.parser_kind_subkind == Some ParserStrong ==> (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ no_lookahead_on_precond p1 sl sl') ==> f sl == f sl'))
let gaccessor_no_lookahead_weaken
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
(sl sl' : bytes)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
gaccessor_pre p1 p2 cl sl /\
no_lookahead_on_precond p1 sl sl'
))
(ensures (gaccessor_pre p1 p2 cl sl'))
= parse_strong_prefix p1 sl sl'
let gaccessor_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
= (forall (sl sl' : bytes) . {:pattern (f sl); (f sl')} (gaccessor_pre p1 p2 cl sl /\ gaccessor_pre p1 p2 cl sl' /\ injective_precond p1 sl sl') ==> f sl == f sl')
let gaccessor_prop'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
= gaccessor_no_lookahead f /\ gaccessor_injective f
val gaccessor_prop
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: GTot Type0
val gaccessor_prop_equiv
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
(f: gaccessor' p1 p2 cl)
: Lemma
(gaccessor_prop f <==> gaccessor_prop' f)
[@unifier_hint_injective]
let gaccessor
(#k1: parser_kind)
(#t1: Type)
(p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(p2: parser k2 t2)
(cl: clens t1 t2)
: Tot Type
= (f: gaccessor' p1 p2 cl { gaccessor_prop f })
let get_gaccessor_clens
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
: Tot (clens t1 t2)
= cl
(*
abstract
let gaccessors_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
: GTot Type0
= // clens_disjoint cl2 cl3 /\
(forall (sl: bytes) . (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
*)
(*
abstract
let gaccessors_disjoint_clens_disjoint
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#pre2: t1 -> GTot Type0)
(#cl2: clens pre2 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#pre3: t1 -> GTot Type0)
(#cl3: clens pre3 t3)
(g3: gaccessor p1 p3 cl3)
: Lemma
(requires (gaccessors_disjoint g2 g3))
(ensures (clens_disjoint cl2 cl3))
[SMTPat (gaccessors_disjoint g2 g3)]
= ()
*)
(*
abstract
let gaccessors_disjoint_elim
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
(sl: bytes)
: Lemma
(requires (gaccessors_disjoint g2 g3 /\ (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
)))
(ensures (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= ()
abstract
let gaccessors_disjoint_intro
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl2: clens t1 t2)
(g2: gaccessor p1 p2 cl2)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl3: clens t1 t3)
(g3: gaccessor p1 p3 cl3)
// (clens_disj: squash (clens_disjoint cl2 cl3))
(lem: (
(sl: bytes) ->
Lemma
(requires (
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
))
(ensures ((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False) /\ (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
)))
))
: Lemma
(gaccessors_disjoint g2 g3)
= let lem'
(sl: bytes)
: Lemma
((
match parse p1 sl with
| Some (x1, consumed1) -> cl2.clens_cond x1 /\ cl3.clens_cond x1 /\ consumed1 == Seq.length sl
| _ -> False
) ==> (
let (pos2, consumed2) = g2 sl in
let (pos3, consumed3) = g3 sl in
pos2 + consumed2 <= pos3 \/ pos3 + consumed3 <= pos2
))
= Classical.move_requires lem sl
in
Classical.forall_intro lem'
*)
let gaccessor_id'
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Ghost (nat)
(requires True)
(ensures (fun res -> gaccessor_post' p p (clens_id _) input res))
= 0
val gaccessor_id
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (gaccessor p p (clens_id _))
val gaccessor_id_eq
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(gaccessor_id p input == gaccessor_id' p input)
let gaccessor_ext'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p2 cl' input res))
= g input
val gaccessor_ext
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
: Tot (gaccessor p1 p2 cl')
val gaccessor_ext_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(cl': clens t1 t2)
(sq: squash (clens_eq cl cl'))
(input: bytes)
: Lemma
(gaccessor_ext g cl' sq input == gaccessor_ext' g cl' sq input)
let gaccessor_compose'
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Ghost (nat) (requires True) (ensures (fun res -> gaccessor_post' p1 p3 (clens_compose cl12 cl23) input res))
= let pos2 = a12 input in
let input2 = Seq.slice input pos2 (Seq.length input) in
let pos3 = a23 input2 in
pos2 + pos3
val gaccessor_compose_injective
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ injective_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose_no_lookahead
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(sl sl': bytes)
: Lemma
(requires (k1.parser_kind_subkind == Some ParserStrong /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl /\ gaccessor_pre p1 p3 (clens_compose cl12 cl23) sl' /\ no_lookahead_on_precond p1 sl sl'))
(ensures (gaccessor_compose' a12 a23 sl == gaccessor_compose' a12 a23 sl'))
val gaccessor_compose
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
: Tot (gaccessor p1 p3 (clens_compose cl12 cl23))
val gaccessor_compose_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23)
(input: bytes)
: Lemma
(gaccessor_compose a12 a23 input == gaccessor_compose' a12 a23 input)
(*
abstract
let gaccessor_compose_strong
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
: Tot (gaccessor p1 p3 (clens_compose_strong cl12 cl23))
= gaccessor_compose' a12 a23
abstract
let gaccessor_compose_strong_eq
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl12: clens t1 t2)
(a12: gaccessor p1 p2 cl12)
(#k3: parser_kind)
(#t3: Type)
(#p3: parser k3 t3)
(#cl23: clens t2 t3)
(a23: gaccessor p2 p3 cl23 { clens_compose_strong_pre cl12 cl23 } )
(input: bytes)
: Lemma
(gaccessor_compose_strong a12 a23 input == gaccessor_compose' a12 a23 input)
= ()
*)
let slice_access'
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos
))
(ensures (fun pos' -> True))
=
let small = bytes_of_slice_from h sl pos in
pos `U32.add` U32.uint_to_t (g small)
val slice_access
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Ghost U32.t
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (fun pos' -> True))
val slice_access_eq
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
valid' p1 h sl pos /\
cl.clens_cond (contents' p1 h sl pos) /\
slice_access h g sl pos == slice_access' h g sl pos
))
let slice_access_post
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos)
))
(ensures (
let pos' = slice_access h g sl pos in
valid p2 h sl pos' /\
contents p2 h sl pos' == cl.clens_get (contents p1 h sl pos) /\
// useful for framing
U32.v pos <= U32.v pos' /\
U32.v pos' + content_length p2 h sl pos' <= U32.v pos + content_length p1 h sl pos
))
[SMTPat (slice_access h g sl pos)]
= slice_access_eq h g sl pos;
valid_facts p1 h sl pos;
assert_norm (pow2 32 == 4294967296);
let res = slice_access' h g sl pos in
valid_facts p2 h sl res
let slice_access_frame_weak
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from sl pos)
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
= valid_facts p1 h sl pos;
valid_facts p1 h' sl pos;
slice_access_eq h g sl pos;
slice_access_eq h' g sl pos;
B.modifies_buffer_from_to_elim sl.base pos sl.len l h h'
val slice_access_frame_strong
(#rrel #rel: _)
(h: HS.mem)
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(#cl: clens t1 t2)
(g: gaccessor p1 p2 cl)
(sl: slice rrel rel)
(pos: U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (
k1.parser_kind_subkind == Some ParserStrong /\
valid p1 h sl pos /\
cl.clens_cond (contents p1 h sl pos) /\
B.modifies l h h' /\
B.loc_disjoint l (loc_slice_from_to sl pos (get_valid_pos p1 h sl pos))
))
(ensures (
valid p1 h' sl pos /\
cl.clens_cond (contents p1 h' sl pos) /\
slice_access h' g sl pos == slice_access h g sl pos
))
[SMTPatOr [
[SMTPat (slice_access h g sl pos); SMTPat (B.modifies l h h')];
[SMTPat (slice_access h' g sl pos); SMTPat (B.modifies l h h')];
]]
(* lists, to avoid putting LowParse.*.List into the user context *)
val valid_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: GTot Type0
(decreases (U32.v pos' - U32.v pos))
val valid_list_equiv
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(valid_list p h sl pos pos' <==> (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos' <= U32.v sl.len /\ (
if pos = pos'
then True
else
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
U32.v pos1 <= U32.v pos' /\
valid_list p h sl pos1 pos'
))))
let valid_list_elim
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (
k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_low > 0 /\
live_slice h sl /\
U32.v pos <= U32.v pos' /\
U32.v pos' <= U32.v sl.len
))
[SMTPat (valid_list p h sl pos pos')]
= valid_list_equiv p h sl pos pos'
val contents_list
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Ghost (list t)
(requires (valid_list p h sl pos pos'))
(ensures (fun _ -> True))
(decreases (U32.v pos' - U32.v pos))
val contents_list_eq
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
: Lemma
(requires (valid_list p h sl pos pos'))
(ensures (contents_list p h sl pos pos' == (
valid_list_equiv p h sl pos pos';
if pos = pos'
then []
else
contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
)))
let valid_list_nil
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
: Lemma
(requires (U32.v pos <= U32.v sl.len /\ live_slice h sl /\ k.parser_kind_low > 0 /\ k.parser_kind_subkind == Some ParserStrong))
(ensures (
valid_list p h sl pos pos /\
contents_list p h sl pos pos == []
))
= valid_list_equiv p h sl pos pos;
contents_list_eq p h sl pos pos
let valid_list_cons
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos'
))
(ensures (
valid p h sl pos /\
valid_list p h sl (get_valid_pos p h sl pos) pos' /\
valid_list p h sl pos pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl (get_valid_pos p h sl pos) pos'
))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
module L = FStar.List.Tot
let valid_list_cons_recip
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos : U32.t)
(pos' : U32.t)
: Lemma
(requires (
pos <> pos' /\
valid_list p h sl pos pos'
))
(ensures (
pos <> pos' /\
valid_list p h sl pos pos' /\
valid p h sl pos /\ (
let pos1 = get_valid_pos p h sl pos in
valid_list p h sl pos1 pos' /\
contents_list p h sl pos pos' == contents p h sl pos :: contents_list p h sl pos1 pos'
)))
= valid_list_equiv p h sl pos pos' ;
contents_list_eq p h sl pos pos'
let rec valid_list_frame_1
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h s pos pos'))
(ensures (
valid_list p h s pos pos' /\ valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h s pos pos';
contents_list_eq p h s pos pos' ;
valid_list_equiv p h' s pos pos' ;
begin if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h s pos in
valid_list_frame_1 p h s pos1 pos' l h'
end end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h' s pos pos'
let rec valid_list_frame_2
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos') /\ valid_list p h' s pos pos'))
(ensures (
valid_list p h' s pos pos' /\ valid_list p h s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
))
(decreases (U32.v pos' - U32.v pos))
= valid_list_equiv p h' s pos pos' ;
contents_list_eq p h' s pos pos' ;
valid_list_equiv p h s pos pos' ;
if pos = pos'
then ()
else begin
let pos1 = get_valid_pos p h' s pos in
valid_valid_exact p h' s pos;
valid_exact_valid p h s pos pos1;
valid_list_frame_2 p h s pos1 pos' l h'
end;
B.modifies_buffer_from_to_elim s.base pos pos' l h h';
contents_list_eq p h s pos pos'
let valid_list_frame
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(s: slice rrel rel)
(pos: U32.t)
(pos' : U32.t)
(l: B.loc)
(h' : HS.mem)
: Lemma
(requires (live_slice h s /\ B.modifies l h h' /\ B.loc_disjoint l (loc_slice_from_to s pos pos')))
(ensures (
(valid_list p h s pos pos' \/ valid_list p h' s pos pos') ==> (
valid_list p h s pos pos' /\
valid_list p h' s pos pos' /\ contents_list p h' s pos pos' == contents_list p h s pos pos'
)))
[SMTPatOr [
[SMTPat (valid_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (valid_list p h' s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h s pos pos'); SMTPat (B.modifies l h h')];
[SMTPat (contents_list p h' s pos pos'); SMTPat (B.modifies l h h')];
]]
= Classical.move_requires (valid_list_frame_1 p h s pos pos' l) h';
Classical.move_requires (valid_list_frame_2 p h s pos pos' l) h'
let rec valid_list_append
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 pos3 : U32.t)
: Lemma
(requires (
valid_list p h sl pos1 pos2 /\
valid_list p h sl pos2 pos3
))
(ensures (
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 == contents_list p h sl pos1 pos2 `L.append` contents_list p h sl pos2 pos3
))
(decreases (U32.v pos2 - U32.v pos1))
= if pos1 = pos2
then
valid_list_nil p h sl pos1
else begin
valid_list_cons_recip p h sl pos1 pos2;
let pos15 = get_valid_pos p h sl pos1 in
valid_list_append p h sl pos15 pos2 pos3;
valid_list_cons p h sl pos1 pos3
end
let valid_list_snoc
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2 : U32.t)
: Lemma
(requires (
valid_list p h sl pos1 pos2 /\
valid p h sl pos2
))
(ensures (
let pos3 = get_valid_pos p h sl pos2 in
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 == contents_list p h sl pos1 pos2 `L.append` [contents p h sl pos2] | false | false | LowParse.Low.Base.Spec.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_list_snoc
(#rrel #rel: _)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(h: HS.mem)
(sl: slice rrel rel)
(pos1 pos2: U32.t)
: Lemma (requires (valid_list p h sl pos1 pos2 /\ valid p h sl pos2))
(ensures
(let pos3 = get_valid_pos p h sl pos2 in
valid_list p h sl pos1 pos3 /\
contents_list p h sl pos1 pos3 ==
(contents_list p h sl pos1 pos2)
`L.append`
[contents p h sl pos2])) | [] | LowParse.Low.Base.Spec.valid_list_snoc | {
"file_name": "src/lowparse/LowParse.Low.Base.Spec.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
p: LowParse.Spec.Base.parser k t ->
h: FStar.Monotonic.HyperStack.mem ->
sl: LowParse.Slice.slice rrel rel ->
pos1: FStar.UInt32.t ->
pos2: FStar.UInt32.t
-> FStar.Pervasives.Lemma
(requires
LowParse.Low.Base.Spec.valid_list p h sl pos1 pos2 /\
LowParse.Low.Base.Spec.valid p h sl pos2)
(ensures
(let pos3 = LowParse.Low.Base.Spec.get_valid_pos p h sl pos2 in
LowParse.Low.Base.Spec.valid_list p h sl pos1 pos3 /\
LowParse.Low.Base.Spec.contents_list p h sl pos1 pos3 ==
LowParse.Low.Base.Spec.contents_list p h sl pos1 pos2 @
[LowParse.Low.Base.Spec.contents p h sl pos2])) | {
"end_col": 41,
"end_line": 2143,
"start_col": 1,
"start_line": 2140
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let store_felem = fields_store_felem_higher #M64 True C.add1 | let store_felem = | false | null | false | fields_store_felem_higher #M64 True C.add1 | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.fields_store_felem_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Impl.Curve25519.Field64.Local.add1"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd
let point_double =
addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd
let montgomery_ladder =
generic_montgomery_ladder_higher #M64 True point_double C.cswap2 point_add_and_double
let fsquare_times = finv_fsquare_times_higher #M64 True C.fsqr
let finv = finv_finv_higher #M64 True C.fmul fsquare_times
// Note that here, for implementations of Curve64, we have a generic store_felem
// over an *implementation* of add1. (For Curve51, store_felem does not have | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val store_felem : Hacl.Meta.Curve25519.fields_store_felem_higher_t Prims.l_True | [] | Hacl.Curve25519_64_Local.store_felem | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Meta.Curve25519.fields_store_felem_higher_t Prims.l_True | {
"end_col": 60,
"end_line": 24,
"start_col": 18,
"start_line": 24
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let finv = finv_finv_higher #M64 True C.fmul fsquare_times | let finv = | false | null | false | finv_finv_higher #M64 True C.fmul fsquare_times | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.finv_finv_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Impl.Curve25519.Field64.Local.fmul",
"Hacl.Curve25519_64_Local.fsquare_times"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd
let point_double =
addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd
let montgomery_ladder =
generic_montgomery_ladder_higher #M64 True point_double C.cswap2 point_add_and_double | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val finv : Hacl.Meta.Curve25519.finv_finv_higher_t Prims.l_True | [] | Hacl.Curve25519_64_Local.finv | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Meta.Curve25519.finv_finv_higher_t Prims.l_True | {
"end_col": 58,
"end_line": 20,
"start_col": 11,
"start_line": 20
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fsquare_times = finv_fsquare_times_higher #M64 True C.fsqr | let fsquare_times = | false | null | false | finv_fsquare_times_higher #M64 True C.fsqr | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.finv_fsquare_times_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Impl.Curve25519.Field64.Local.fsqr"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd
let point_double =
addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd
let montgomery_ladder = | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fsquare_times : Hacl.Meta.Curve25519.finv_fsquare_times_higher_t Prims.l_True | [] | Hacl.Curve25519_64_Local.fsquare_times | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Meta.Curve25519.finv_fsquare_times_higher_t Prims.l_True | {
"end_col": 62,
"end_line": 19,
"start_col": 20,
"start_line": 19
} |
|
Prims.Tot | val scalarmult: scalarmult_st M64 True | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let scalarmult = generic_scalarmult_higher #M64 True encode_point montgomery_ladder decode_point | val scalarmult: scalarmult_st M64 True
let scalarmult = | false | null | false | generic_scalarmult_higher #M64 True encode_point montgomery_ladder decode_point | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.generic_scalarmult_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Curve25519_64_Local.encode_point",
"Hacl.Curve25519_64_Local.montgomery_ladder",
"Hacl.Impl.Curve25519.Generic.decode_point"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd
let point_double =
addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd
let montgomery_ladder =
generic_montgomery_ladder_higher #M64 True point_double C.cswap2 point_add_and_double
let fsquare_times = finv_fsquare_times_higher #M64 True C.fsqr
let finv = finv_finv_higher #M64 True C.fmul fsquare_times
// Note that here, for implementations of Curve64, we have a generic store_felem
// over an *implementation* of add1. (For Curve51, store_felem does not have
// that generic aspect.)
let store_felem = fields_store_felem_higher #M64 True C.add1 | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val scalarmult: scalarmult_st M64 True | [] | Hacl.Curve25519_64_Local.scalarmult | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Curve25519.Generic.scalarmult_st Hacl.Impl.Curve25519.Fields.Core.M64 Prims.l_True | {
"end_col": 96,
"end_line": 26,
"start_col": 17,
"start_line": 26
} |
Prims.Tot | val ecdh: ecdh_st M64 True | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ecdh = generic_ecdh_higher #M64 True scalarmult | val ecdh: ecdh_st M64 True
let ecdh = | false | null | false | generic_ecdh_higher #M64 True scalarmult | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.generic_ecdh_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Curve25519_64_Local.scalarmult"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd
let point_double =
addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd
let montgomery_ladder =
generic_montgomery_ladder_higher #M64 True point_double C.cswap2 point_add_and_double
let fsquare_times = finv_fsquare_times_higher #M64 True C.fsqr
let finv = finv_finv_higher #M64 True C.fmul fsquare_times
// Note that here, for implementations of Curve64, we have a generic store_felem
// over an *implementation* of add1. (For Curve51, store_felem does not have
// that generic aspect.)
let store_felem = fields_store_felem_higher #M64 True C.add1
let encode_point = generic_encode_point_higher #M64 True store_felem C.fmul finv
let scalarmult = generic_scalarmult_higher #M64 True encode_point montgomery_ladder decode_point | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ecdh: ecdh_st M64 True | [] | Hacl.Curve25519_64_Local.ecdh | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Curve25519.Generic.ecdh_st Hacl.Impl.Curve25519.Fields.Core.M64 Prims.l_True | {
"end_col": 51,
"end_line": 28,
"start_col": 11,
"start_line": 28
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let encode_point = generic_encode_point_higher #M64 True store_felem C.fmul finv | let encode_point = | false | null | false | generic_encode_point_higher #M64 True store_felem C.fmul finv | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.generic_encode_point_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Curve25519_64_Local.store_felem",
"Hacl.Impl.Curve25519.Field64.Local.fmul",
"Hacl.Curve25519_64_Local.finv"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd
let point_double =
addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd
let montgomery_ladder =
generic_montgomery_ladder_higher #M64 True point_double C.cswap2 point_add_and_double
let fsquare_times = finv_fsquare_times_higher #M64 True C.fsqr
let finv = finv_finv_higher #M64 True C.fmul fsquare_times
// Note that here, for implementations of Curve64, we have a generic store_felem
// over an *implementation* of add1. (For Curve51, store_felem does not have
// that generic aspect.) | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val encode_point : Hacl.Meta.Curve25519.generic_encode_point_higher_t Prims.l_True | [] | Hacl.Curve25519_64_Local.encode_point | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Meta.Curve25519.generic_encode_point_higher_t Prims.l_True | {
"end_col": 80,
"end_line": 25,
"start_col": 19,
"start_line": 25
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let montgomery_ladder =
generic_montgomery_ladder_higher #M64 True point_double C.cswap2 point_add_and_double | let montgomery_ladder = | false | null | false | generic_montgomery_ladder_higher #M64 True point_double C.cswap2 point_add_and_double | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.generic_montgomery_ladder_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Curve25519_64_Local.point_double",
"Hacl.Impl.Curve25519.Field64.Local.cswap2",
"Hacl.Curve25519_64_Local.point_add_and_double"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd
let point_double =
addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val montgomery_ladder : Hacl.Meta.Curve25519.generic_montgomery_ladder_higher_t Prims.l_True | [] | Hacl.Curve25519_64_Local.montgomery_ladder | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Meta.Curve25519.generic_montgomery_ladder_higher_t Prims.l_True | {
"end_col": 87,
"end_line": 18,
"start_col": 2,
"start_line": 18
} |
|
Prims.Tot | val secret_to_public: secret_to_public_st M64 True | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let secret_to_public = generic_secret_to_public_higher #M64 True scalarmult g25519 | val secret_to_public: secret_to_public_st M64 True
let secret_to_public = | false | null | false | generic_secret_to_public_higher #M64 True scalarmult g25519 | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.generic_secret_to_public_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Curve25519_64_Local.scalarmult",
"Hacl.Curve25519_64_Local.g25519"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd
let point_double =
addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd
let montgomery_ladder =
generic_montgomery_ladder_higher #M64 True point_double C.cswap2 point_add_and_double
let fsquare_times = finv_fsquare_times_higher #M64 True C.fsqr
let finv = finv_finv_higher #M64 True C.fmul fsquare_times
// Note that here, for implementations of Curve64, we have a generic store_felem
// over an *implementation* of add1. (For Curve51, store_felem does not have
// that generic aspect.)
let store_felem = fields_store_felem_higher #M64 True C.add1
let encode_point = generic_encode_point_higher #M64 True store_felem C.fmul finv | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val secret_to_public: secret_to_public_st M64 True | [] | Hacl.Curve25519_64_Local.secret_to_public | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Curve25519.Generic.secret_to_public_st Hacl.Impl.Curve25519.Fields.Core.M64 Prims.l_True | {
"end_col": 82,
"end_line": 27,
"start_col": 23,
"start_line": 27
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd | let point_add_and_double = | false | null | false | addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.addanddouble_point_add_and_double_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Impl.Curve25519.Field64.Local.fmul",
"Hacl.Impl.Curve25519.Field64.Local.fsqr2",
"Hacl.Impl.Curve25519.Field64.Local.fmul1",
"Hacl.Impl.Curve25519.Field64.Local.fmul2",
"Hacl.Impl.Curve25519.Field64.Local.fsub",
"Hacl.Impl.Curve25519.Field64.Local.fadd"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100" | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_add_and_double : Hacl.Meta.Curve25519.addanddouble_point_add_and_double_higher_t Prims.l_True | [] | Hacl.Curve25519_64_Local.point_add_and_double | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Meta.Curve25519.addanddouble_point_add_and_double_higher_t Prims.l_True | {
"end_col": 97,
"end_line": 14,
"start_col": 2,
"start_line": 14
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let point_double =
addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd | let point_double = | false | null | false | addanddouble_point_double_higher #M64 True C.fmul2 C.fmul1 C.fsqr2 C.fsub C.fadd | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Hacl.Meta.Curve25519.addanddouble_point_double_higher",
"Hacl.Impl.Curve25519.Fields.Core.M64",
"Prims.l_True",
"Hacl.Impl.Curve25519.Field64.Local.fmul2",
"Hacl.Impl.Curve25519.Field64.Local.fmul1",
"Hacl.Impl.Curve25519.Field64.Local.fsqr2",
"Hacl.Impl.Curve25519.Field64.Local.fsub",
"Hacl.Impl.Curve25519.Field64.Local.fadd"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local
let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list
#set-options "--max_fuel 0 --max_ifuel 0 --z3rlimit 100"
let point_add_and_double =
addanddouble_point_add_and_double_higher #M64 True C.fmul C.fsqr2 C.fmul1 C.fmul2 C.fsub C.fadd | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 100,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val point_double : Hacl.Meta.Curve25519.addanddouble_point_double_higher_t Prims.l_True | [] | Hacl.Curve25519_64_Local.point_double | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Meta.Curve25519.addanddouble_point_double_higher_t Prims.l_True | {
"end_col": 82,
"end_line": 16,
"start_col": 2,
"start_line": 16
} |
|
Prims.Tot | val g25519:g25519_t | [
{
"abbrev": true,
"full_module": "Hacl.Impl.Curve25519.Field64.Local",
"short_module": "C"
},
{
"abbrev": false,
"full_module": "Hacl.Meta.Curve25519",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Fields",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl.Curve25519.Generic",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let g25519: g25519_t =
Lib.Buffer.createL_global Spec.Curve25519.basepoint_list | val g25519:g25519_t
let g25519:g25519_t = | false | null | false | Lib.Buffer.createL_global Spec.Curve25519.basepoint_list | {
"checked_file": "Hacl.Curve25519_64_Local.fst.checked",
"dependencies": [
"Spec.Curve25519.fst.checked",
"prims.fst.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Meta.Curve25519.fst.checked",
"Hacl.Impl.Curve25519.Field64.Local.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Hacl.Curve25519_64_Local.fst"
} | [
"total"
] | [
"Lib.Buffer.createL_global",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.PUB",
"Spec.Curve25519.basepoint_list",
"Lib.Buffer.glbuffer",
"Lib.IntTypes.size",
"FStar.Pervasives.normalize_term",
"Lib.IntTypes.size_nat",
"FStar.List.Tot.Base.length"
] | [] | module Hacl.Curve25519_64_Local
friend Hacl.Meta.Curve25519
open Hacl.Meta.Curve25519
// The assumed core.
module C = Hacl.Impl.Curve25519.Field64.Local | false | true | Hacl.Curve25519_64_Local.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val g25519:g25519_t | [] | Hacl.Curve25519_64_Local.g25519 | {
"file_name": "code/curve25519/Hacl.Curve25519_64_Local.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Hacl.Impl.Curve25519.Generic.g25519_t | {
"end_col": 58,
"end_line": 10,
"start_col": 2,
"start_line": 10
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let machine_state_eq (s1 s2:state) =
s1 == s2 | let machine_state_eq (s1 s2: state) = | false | null | false | s1 == s2 | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.State.state",
"Prims.eq2",
"Prims.logical"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') }
[@va_qattr]
let update_vec (vr:vec) (v:quad32) (s:state) : state =
{ s with vecs = vecs_make (fun (vr':vec) -> if vr' = vr then v else s.vecs vr') }
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:state) : GTot state =
{s with ms_stack = VSS.stack_to_s (store_stack64 ptr v (VSS.stack_from_s s.ms_stack))}
[@va_qattr]
let valid_maddr (m:maddr) (s:state) : prop0 =
M.valid_mem64 (eval_maddr m s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let valid_mem (m:maddr) (s:state) : prop0 =
valid_maddr_offset64 m.offset /\ valid_maddr m s
[@va_qattr]
let valid_mem128 (r:reg) (i:reg) (s:state) : prop0 =
M.valid_mem128 (eval_reg r s + eval_reg i s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let state_eta (s:state) : state =
{s with
ms_heap = coerce ({ (coerce s.ms_heap) with vf_heaplets = Map16.eta (coerce s.ms_heap).vf_heaplets });
}
[@va_qattr]
let state_eq (s0:state) (s1:state) : prop0 =
s0.ok == s1.ok /\
Regs.equal s0.regs s1.regs /\
Vecs.equal s0.vecs s1.vecs /\
s0.cr0 == s1.cr0 /\
s0.xer == s1.xer /\
M.vale_full_heap_equal (coerce s0.ms_heap) (coerce s1.ms_heap) /\
s0.ms_stack == s1.ms_stack /\
s0.ms_stackTaint == s1.ms_stackTaint | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val machine_state_eq : s1: Vale.PPC64LE.State.state -> s2: Vale.PPC64LE.State.state -> Prims.logical | [] | Vale.PPC64LE.State.machine_state_eq | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s1: Vale.PPC64LE.State.state -> s2: Vale.PPC64LE.State.state -> Prims.logical | {
"end_col": 10,
"end_line": 82,
"start_col": 2,
"start_line": 82
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let state = Vale.PPC64LE.Machine_s.state | let state = | false | null | false | Vale.PPC64LE.Machine_s.state | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.state"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state : Type | [] | Vale.PPC64LE.State.state | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Type | {
"end_col": 47,
"end_line": 16,
"start_col": 19,
"start_line": 16
} |
|
Prims.GTot | val eval_stack128 (ptr: int) (s: state) : GTot quad32 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack) | val eval_stack128 (ptr: int) (s: state) : GTot quad32
let eval_stack128 (ptr: int) (s: state) : GTot quad32 = | false | null | false | load_stack128 ptr (VSS.stack_from_s s.ms_stack) | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"sometrivial"
] | [
"Prims.int",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Stack_i.load_stack128",
"Vale.PPC64LE.Stack_Sems.stack_from_s",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.PPC64LE.Machine_s.quad32"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack) | false | false | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_stack128 (ptr: int) (s: state) : GTot quad32 | [] | Vale.PPC64LE.State.eval_stack128 | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> s: Vale.PPC64LE.State.state -> Prims.GTot Vale.PPC64LE.Machine_s.quad32 | {
"end_col": 108,
"end_line": 38,
"start_col": 61,
"start_line": 38
} |
Prims.Tot | val eval_vec (v: vec) (s: state) : quad32 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_vec (v:vec) (s:state) : quad32 = s.vecs v | val eval_vec (v: vec) (s: state) : quad32
let eval_vec (v: vec) (s: state) : quad32 = | false | null | false | s.vecs v | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.vec",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__vecs",
"Vale.PPC64LE.Machine_s.quad32"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_vec (v: vec) (s: state) : quad32 | [] | Vale.PPC64LE.State.eval_vec | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | v: Vale.PPC64LE.Machine_s.vec -> s: Vale.PPC64LE.State.state -> Vale.PPC64LE.Machine_s.quad32 | {
"end_col": 57,
"end_line": 21,
"start_col": 49,
"start_line": 21
} |
Prims.Tot | val valid_mem (m: maddr) (s: state) : prop0 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_mem (m:maddr) (s:state) : prop0 =
valid_maddr_offset64 m.offset /\ valid_maddr m s | val valid_mem (m: maddr) (s: state) : prop0
let valid_mem (m: maddr) (s: state) : prop0 = | false | null | false | valid_maddr_offset64 m.offset /\ valid_maddr m s | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.maddr",
"Vale.PPC64LE.State.state",
"Prims.l_and",
"Prims.b2t",
"Vale.PPC64LE.Machine_s.valid_maddr_offset64",
"Vale.PPC64LE.Machine_s.__proj__Mkmaddr__item__offset",
"Vale.PPC64LE.State.valid_maddr",
"Vale.Def.Prop_s.prop0"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') }
[@va_qattr]
let update_vec (vr:vec) (v:quad32) (s:state) : state =
{ s with vecs = vecs_make (fun (vr':vec) -> if vr' = vr then v else s.vecs vr') }
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:state) : GTot state =
{s with ms_stack = VSS.stack_to_s (store_stack64 ptr v (VSS.stack_from_s s.ms_stack))}
[@va_qattr]
let valid_maddr (m:maddr) (s:state) : prop0 =
M.valid_mem64 (eval_maddr m s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr] | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_mem (m: maddr) (s: state) : prop0 | [] | Vale.PPC64LE.State.valid_mem | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.PPC64LE.Machine_s.maddr -> s: Vale.PPC64LE.State.state -> Vale.Def.Prop_s.prop0 | {
"end_col": 50,
"end_line": 58,
"start_col": 2,
"start_line": 58
} |
Prims.Tot | val eval_reg (r: reg) (s: state) : nat64 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_reg (r:reg) (s:state) : nat64 = s.regs r | val eval_reg (r: reg) (s: state) : nat64
let eval_reg (r: reg) (s: state) : nat64 = | false | null | false | s.regs r | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.reg",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__regs",
"Vale.PPC64LE.Machine_s.nat64"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_reg (r: reg) (s: state) : nat64 | [] | Vale.PPC64LE.State.eval_reg | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Vale.PPC64LE.Machine_s.reg -> s: Vale.PPC64LE.State.state -> Vale.PPC64LE.Machine_s.nat64 | {
"end_col": 56,
"end_line": 19,
"start_col": 48,
"start_line": 19
} |
Prims.GTot | val update_stack64 (ptr: int) (v: nat64) (s: state) : GTot state | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_stack64 (ptr:int) (v:nat64) (s:state) : GTot state =
{s with ms_stack = VSS.stack_to_s (store_stack64 ptr v (VSS.stack_from_s s.ms_stack))} | val update_stack64 (ptr: int) (v: nat64) (s: state) : GTot state
let update_stack64 (ptr: int) (v: nat64) (s: state) : GTot state = | false | null | false | { s with ms_stack = VSS.stack_to_s (store_stack64 ptr v (VSS.stack_from_s s.ms_stack)) } | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"sometrivial"
] | [
"Prims.int",
"Vale.PPC64LE.Machine_s.nat64",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Machine_s.Mkstate",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ok",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__regs",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__vecs",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__cr0",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__xer",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.PPC64LE.Stack_Sems.stack_to_s",
"Vale.PPC64LE.Stack_i.store_stack64",
"Vale.PPC64LE.Stack_Sems.stack_from_s",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stackTaint"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') }
[@va_qattr]
let update_vec (vr:vec) (v:quad32) (s:state) : state =
{ s with vecs = vecs_make (fun (vr':vec) -> if vr' = vr then v else s.vecs vr') }
[@va_qattr] | false | false | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_stack64 (ptr: int) (v: nat64) (s: state) : GTot state | [] | Vale.PPC64LE.State.update_stack64 | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> v: Vale.PPC64LE.Machine_s.nat64 -> s: Vale.PPC64LE.State.state
-> Prims.GTot Vale.PPC64LE.State.state | {
"end_col": 87,
"end_line": 50,
"start_col": 3,
"start_line": 50
} |
Prims.GTot | val eval_stack (ptr: int) (s: state) : GTot nat64 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack) | val eval_stack (ptr: int) (s: state) : GTot nat64
let eval_stack (ptr: int) (s: state) : GTot nat64 = | false | null | false | load_stack64 ptr (VSS.stack_from_s s.ms_stack) | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"sometrivial"
] | [
"Prims.int",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Stack_i.load_stack64",
"Vale.PPC64LE.Stack_Sems.stack_from_s",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.PPC64LE.Machine_s.nat64"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n | false | false | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_stack (ptr: int) (s: state) : GTot nat64 | [] | Vale.PPC64LE.State.eval_stack | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> s: Vale.PPC64LE.State.state -> Prims.GTot Vale.PPC64LE.Machine_s.nat64 | {
"end_col": 103,
"end_line": 36,
"start_col": 57,
"start_line": 36
} |
Prims.Tot | val eval_maddr (m: maddr) (s: state) : int | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset | val eval_maddr (m: maddr) (s: state) : int
let eval_maddr (m: maddr) (s: state) : int = | false | null | false | eval_reg m.address s + m.offset | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.maddr",
"Vale.PPC64LE.State.state",
"Prims.op_Addition",
"Vale.PPC64LE.State.eval_reg",
"Vale.PPC64LE.Machine_s.__proj__Mkmaddr__item__address",
"Vale.PPC64LE.Machine_s.__proj__Mkmaddr__item__offset",
"Prims.int"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr] | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_maddr (m: maddr) (s: state) : int | [] | Vale.PPC64LE.State.eval_maddr | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.PPC64LE.Machine_s.maddr -> s: Vale.PPC64LE.State.state -> Prims.int | {
"end_col": 33,
"end_line": 27,
"start_col": 2,
"start_line": 27
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let machine_state_equal (s1 s2:state) =
s1.ok == s2.ok /\
Regs.equal s1.regs s2.regs /\
Vecs.equal s1.vecs s2.vecs /\
s1.cr0 == s2.cr0 /\
s1.xer == s2.xer /\
s1.ms_heap == s2.ms_heap /\
s1.ms_stack == s2.ms_stack /\
s1.ms_stackTaint == s2.ms_stackTaint /\
True | let machine_state_equal (s1 s2: state) = | false | null | false | s1.ok == s2.ok /\ Regs.equal s1.regs s2.regs /\ Vecs.equal s1.vecs s2.vecs /\ s1.cr0 == s2.cr0 /\
s1.xer == s2.xer /\ s1.ms_heap == s2.ms_heap /\ s1.ms_stack == s2.ms_stack /\
s1.ms_stackTaint == s2.ms_stackTaint /\ True | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.State.state",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ok",
"Vale.PPC64LE.Regs.equal",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__regs",
"Vale.PPC64LE.Vecs.equal",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__vecs",
"Vale.PPC64LE.Machine_s.cr0_t",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__cr0",
"Vale.PPC64LE.Machine_s.xer_t",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__xer",
"Vale.Arch.Heap.heap_impl",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.PPC64LE.Machine_s.machine_stack",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.Arch.HeapTypes_s.memTaint_t",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stackTaint",
"Prims.l_True",
"Prims.logical"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') }
[@va_qattr]
let update_vec (vr:vec) (v:quad32) (s:state) : state =
{ s with vecs = vecs_make (fun (vr':vec) -> if vr' = vr then v else s.vecs vr') }
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:state) : GTot state =
{s with ms_stack = VSS.stack_to_s (store_stack64 ptr v (VSS.stack_from_s s.ms_stack))}
[@va_qattr]
let valid_maddr (m:maddr) (s:state) : prop0 =
M.valid_mem64 (eval_maddr m s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let valid_mem (m:maddr) (s:state) : prop0 =
valid_maddr_offset64 m.offset /\ valid_maddr m s
[@va_qattr]
let valid_mem128 (r:reg) (i:reg) (s:state) : prop0 =
M.valid_mem128 (eval_reg r s + eval_reg i s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let state_eta (s:state) : state =
{s with
ms_heap = coerce ({ (coerce s.ms_heap) with vf_heaplets = Map16.eta (coerce s.ms_heap).vf_heaplets });
}
[@va_qattr]
let state_eq (s0:state) (s1:state) : prop0 =
s0.ok == s1.ok /\
Regs.equal s0.regs s1.regs /\
Vecs.equal s0.vecs s1.vecs /\
s0.cr0 == s1.cr0 /\
s0.xer == s1.xer /\
M.vale_full_heap_equal (coerce s0.ms_heap) (coerce s1.ms_heap) /\
s0.ms_stack == s1.ms_stack /\
s0.ms_stackTaint == s1.ms_stackTaint
let machine_state_eq (s1 s2:state) =
s1 == s2 | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val machine_state_equal : s1: Vale.PPC64LE.State.state -> s2: Vale.PPC64LE.State.state -> Prims.logical | [] | Vale.PPC64LE.State.machine_state_equal | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s1: Vale.PPC64LE.State.state -> s2: Vale.PPC64LE.State.state -> Prims.logical | {
"end_col": 6,
"end_line": 93,
"start_col": 2,
"start_line": 85
} |
|
Prims.Tot | val coerce (#b #a: Type) (x: a{a == b}) : b | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let coerce (#b #a:Type) (x:a{a == b}) : b = x | val coerce (#b #a: Type) (x: a{a == b}) : b
let coerce (#b #a: Type) (x: a{a == b}) : b = | false | null | false | x | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Prims.eq2"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems | false | false | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val coerce (#b #a: Type) (x: a{a == b}) : b | [] | Vale.PPC64LE.State.coerce | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: a{a == b} -> b | {
"end_col": 52,
"end_line": 14,
"start_col": 51,
"start_line": 14
} |
Prims.Tot | val valid_mem128 (r i: reg) (s: state) : prop0 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_mem128 (r:reg) (i:reg) (s:state) : prop0 =
M.valid_mem128 (eval_reg r s + eval_reg i s) (M.get_vale_heap (coerce s.ms_heap)) | val valid_mem128 (r i: reg) (s: state) : prop0
let valid_mem128 (r i: reg) (s: state) : prop0 = | false | null | false | M.valid_mem128 (eval_reg r s + eval_reg i s) (M.get_vale_heap (coerce s.ms_heap)) | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.reg",
"Vale.PPC64LE.State.state",
"Prims.b2t",
"Vale.PPC64LE.Memory.valid_mem128",
"Prims.op_Addition",
"Vale.PPC64LE.State.eval_reg",
"Vale.PPC64LE.Memory.get_vale_heap",
"Vale.PPC64LE.State.coerce",
"Vale.PPC64LE.Memory.vale_full_heap",
"Vale.Arch.Heap.heap_impl",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.Def.Prop_s.prop0"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') }
[@va_qattr]
let update_vec (vr:vec) (v:quad32) (s:state) : state =
{ s with vecs = vecs_make (fun (vr':vec) -> if vr' = vr then v else s.vecs vr') }
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:state) : GTot state =
{s with ms_stack = VSS.stack_to_s (store_stack64 ptr v (VSS.stack_from_s s.ms_stack))}
[@va_qattr]
let valid_maddr (m:maddr) (s:state) : prop0 =
M.valid_mem64 (eval_maddr m s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let valid_mem (m:maddr) (s:state) : prop0 =
valid_maddr_offset64 m.offset /\ valid_maddr m s
[@va_qattr] | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_mem128 (r i: reg) (s: state) : prop0 | [] | Vale.PPC64LE.State.valid_mem128 | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Vale.PPC64LE.Machine_s.reg -> i: Vale.PPC64LE.Machine_s.reg -> s: Vale.PPC64LE.State.state
-> Vale.Def.Prop_s.prop0 | {
"end_col": 83,
"end_line": 62,
"start_col": 2,
"start_line": 62
} |
Prims.Tot | val valid_maddr (m: maddr) (s: state) : prop0 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let valid_maddr (m:maddr) (s:state) : prop0 =
M.valid_mem64 (eval_maddr m s) (M.get_vale_heap (coerce s.ms_heap)) | val valid_maddr (m: maddr) (s: state) : prop0
let valid_maddr (m: maddr) (s: state) : prop0 = | false | null | false | M.valid_mem64 (eval_maddr m s) (M.get_vale_heap (coerce s.ms_heap)) | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.maddr",
"Vale.PPC64LE.State.state",
"Prims.b2t",
"Vale.PPC64LE.Memory.valid_mem64",
"Vale.PPC64LE.State.eval_maddr",
"Vale.PPC64LE.Memory.get_vale_heap",
"Vale.PPC64LE.State.coerce",
"Vale.PPC64LE.Memory.vale_full_heap",
"Vale.Arch.Heap.heap_impl",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.Def.Prop_s.prop0"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') }
[@va_qattr]
let update_vec (vr:vec) (v:quad32) (s:state) : state =
{ s with vecs = vecs_make (fun (vr':vec) -> if vr' = vr then v else s.vecs vr') }
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:state) : GTot state =
{s with ms_stack = VSS.stack_to_s (store_stack64 ptr v (VSS.stack_from_s s.ms_stack))}
[@va_qattr] | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val valid_maddr (m: maddr) (s: state) : prop0 | [] | Vale.PPC64LE.State.valid_maddr | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | m: Vale.PPC64LE.Machine_s.maddr -> s: Vale.PPC64LE.State.state -> Vale.Def.Prop_s.prop0 | {
"end_col": 69,
"end_line": 54,
"start_col": 2,
"start_line": 54
} |
Prims.Tot | val state_eta (s: state) : state | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let state_eta (s:state) : state =
{s with
ms_heap = coerce ({ (coerce s.ms_heap) with vf_heaplets = Map16.eta (coerce s.ms_heap).vf_heaplets });
} | val state_eta (s: state) : state
let state_eta (s: state) : state = | false | null | false | {
s with
ms_heap
=
coerce ({ (coerce s.ms_heap) with vf_heaplets = Map16.eta (coerce s.ms_heap).vf_heaplets })
} | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Machine_s.Mkstate",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ok",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__regs",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__vecs",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__cr0",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__xer",
"Vale.PPC64LE.State.coerce",
"Vale.Arch.Heap.heap_impl",
"Vale.Arch.HeapImpl.vale_full_heap",
"Vale.Arch.HeapImpl.Mkvale_full_heap",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_layout",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_heap",
"Vale.Lib.Map16.eta",
"Vale.Arch.HeapImpl.vale_heap",
"Vale.Arch.HeapImpl.__proj__Mkvale_full_heap__item__vf_heaplets",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stackTaint"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') }
[@va_qattr]
let update_vec (vr:vec) (v:quad32) (s:state) : state =
{ s with vecs = vecs_make (fun (vr':vec) -> if vr' = vr then v else s.vecs vr') }
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:state) : GTot state =
{s with ms_stack = VSS.stack_to_s (store_stack64 ptr v (VSS.stack_from_s s.ms_stack))}
[@va_qattr]
let valid_maddr (m:maddr) (s:state) : prop0 =
M.valid_mem64 (eval_maddr m s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let valid_mem (m:maddr) (s:state) : prop0 =
valid_maddr_offset64 m.offset /\ valid_maddr m s
[@va_qattr]
let valid_mem128 (r:reg) (i:reg) (s:state) : prop0 =
M.valid_mem128 (eval_reg r s + eval_reg i s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr] | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_eta (s: state) : state | [] | Vale.PPC64LE.State.state_eta | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Vale.PPC64LE.State.state -> Vale.PPC64LE.State.state | {
"end_col": 106,
"end_line": 67,
"start_col": 3,
"start_line": 66
} |
Prims.GTot | val eval_mem (ptr: int) (s: state) : GTot nat64 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap)) | val eval_mem (ptr: int) (s: state) : GTot nat64
let eval_mem (ptr: int) (s: state) : GTot nat64 = | false | null | false | M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap)) | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"sometrivial"
] | [
"Prims.int",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Memory.load_mem64",
"Vale.PPC64LE.Memory.get_vale_heap",
"Vale.PPC64LE.State.coerce",
"Vale.PPC64LE.Memory.vale_full_heap",
"Vale.Arch.Heap.heap_impl",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.PPC64LE.Machine_s.nat64"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v | false | false | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_mem (ptr: int) (s: state) : GTot nat64 | [] | Vale.PPC64LE.State.eval_mem | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | ptr: Prims.int -> s: Vale.PPC64LE.State.state -> Prims.GTot Vale.PPC64LE.Machine_s.nat64 | {
"end_col": 108,
"end_line": 23,
"start_col": 55,
"start_line": 23
} |
Prims.Tot | val update_reg (r: reg) (v: nat64) (s: state) : state | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') } | val update_reg (r: reg) (v: nat64) (s: state) : state
let update_reg (r: reg) (v: nat64) (s: state) : state = | false | null | false | { s with regs = regs_make (fun (r': reg) -> if r = r' then v else s.regs r') } | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.reg",
"Vale.PPC64LE.Machine_s.nat64",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Machine_s.Mkstate",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ok",
"Vale.PPC64LE.Machine_s.regs_make",
"Prims.op_Equality",
"Prims.bool",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__regs",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__vecs",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__cr0",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__xer",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stackTaint"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr] | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_reg (r: reg) (v: nat64) (s: state) : state | [] | Vale.PPC64LE.State.update_reg | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | r: Vale.PPC64LE.Machine_s.reg -> v: Vale.PPC64LE.Machine_s.nat64 -> s: Vale.PPC64LE.State.state
-> Vale.PPC64LE.State.state | {
"end_col": 77,
"end_line": 42,
"start_col": 4,
"start_line": 42
} |
Prims.Tot | val update_vec (vr: vec) (v: quad32) (s: state) : state | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let update_vec (vr:vec) (v:quad32) (s:state) : state =
{ s with vecs = vecs_make (fun (vr':vec) -> if vr' = vr then v else s.vecs vr') } | val update_vec (vr: vec) (v: quad32) (s: state) : state
let update_vec (vr: vec) (v: quad32) (s: state) : state = | false | null | false | { s with vecs = vecs_make (fun (vr': vec) -> if vr' = vr then v else s.vecs vr') } | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.vec",
"Vale.PPC64LE.Machine_s.quad32",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Machine_s.Mkstate",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ok",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__regs",
"Vale.PPC64LE.Machine_s.vecs_make",
"Prims.op_Equality",
"Prims.bool",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__vecs",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__cr0",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__xer",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stackTaint"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') }
[@va_qattr] | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val update_vec (vr: vec) (v: quad32) (s: state) : state | [] | Vale.PPC64LE.State.update_vec | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | vr: Vale.PPC64LE.Machine_s.vec -> v: Vale.PPC64LE.Machine_s.quad32 -> s: Vale.PPC64LE.State.state
-> Vale.PPC64LE.State.state | {
"end_col": 81,
"end_line": 46,
"start_col": 4,
"start_line": 46
} |
Prims.Tot | val state_eq (s0 s1: state) : prop0 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let state_eq (s0:state) (s1:state) : prop0 =
s0.ok == s1.ok /\
Regs.equal s0.regs s1.regs /\
Vecs.equal s0.vecs s1.vecs /\
s0.cr0 == s1.cr0 /\
s0.xer == s1.xer /\
M.vale_full_heap_equal (coerce s0.ms_heap) (coerce s1.ms_heap) /\
s0.ms_stack == s1.ms_stack /\
s0.ms_stackTaint == s1.ms_stackTaint | val state_eq (s0 s1: state) : prop0
let state_eq (s0 s1: state) : prop0 = | false | null | false | s0.ok == s1.ok /\ Regs.equal s0.regs s1.regs /\ Vecs.equal s0.vecs s1.vecs /\ s0.cr0 == s1.cr0 /\
s0.xer == s1.xer /\ M.vale_full_heap_equal (coerce s0.ms_heap) (coerce s1.ms_heap) /\
s0.ms_stack == s1.ms_stack /\ s0.ms_stackTaint == s1.ms_stackTaint | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.State.state",
"Prims.l_and",
"Prims.eq2",
"Prims.bool",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ok",
"Vale.PPC64LE.Regs.equal",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__regs",
"Vale.PPC64LE.Vecs.equal",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__vecs",
"Vale.PPC64LE.Machine_s.cr0_t",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__cr0",
"Vale.PPC64LE.Machine_s.xer_t",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__xer",
"Vale.PPC64LE.Memory.vale_full_heap_equal",
"Vale.PPC64LE.State.coerce",
"Vale.PPC64LE.Memory.vale_full_heap",
"Vale.Arch.Heap.heap_impl",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_heap",
"Vale.PPC64LE.Machine_s.machine_stack",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stack",
"Vale.Arch.HeapTypes_s.memTaint_t",
"Vale.PPC64LE.Machine_s.__proj__Mkstate__item__ms_stackTaint",
"Vale.Def.Prop_s.prop0"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr]
let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n
[@va_qattr]
unfold let eval_stack (ptr:int) (s:state) : GTot nat64 = load_stack64 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
unfold let eval_stack128 (ptr:int) (s:state) : GTot quad32 = load_stack128 ptr (VSS.stack_from_s s.ms_stack)
[@va_qattr]
let update_reg (r:reg) (v:nat64) (s:state) : state =
{ s with regs = regs_make (fun (r':reg) -> if r = r' then v else s.regs r') }
[@va_qattr]
let update_vec (vr:vec) (v:quad32) (s:state) : state =
{ s with vecs = vecs_make (fun (vr':vec) -> if vr' = vr then v else s.vecs vr') }
[@va_qattr]
let update_stack64 (ptr:int) (v:nat64) (s:state) : GTot state =
{s with ms_stack = VSS.stack_to_s (store_stack64 ptr v (VSS.stack_from_s s.ms_stack))}
[@va_qattr]
let valid_maddr (m:maddr) (s:state) : prop0 =
M.valid_mem64 (eval_maddr m s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let valid_mem (m:maddr) (s:state) : prop0 =
valid_maddr_offset64 m.offset /\ valid_maddr m s
[@va_qattr]
let valid_mem128 (r:reg) (i:reg) (s:state) : prop0 =
M.valid_mem128 (eval_reg r s + eval_reg i s) (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let state_eta (s:state) : state =
{s with
ms_heap = coerce ({ (coerce s.ms_heap) with vf_heaplets = Map16.eta (coerce s.ms_heap).vf_heaplets });
}
[@va_qattr] | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_eq (s0 s1: state) : prop0 | [] | Vale.PPC64LE.State.state_eq | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s0: Vale.PPC64LE.State.state -> s1: Vale.PPC64LE.State.state -> Vale.Def.Prop_s.prop0 | {
"end_col": 38,
"end_line": 79,
"start_col": 2,
"start_line": 72
} |
Prims.Tot | val eval_cmp_opr (o: cmp_opr) (s: state) : nat64 | [
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Stack_Sems",
"short_module": "VSS"
},
{
"abbrev": true,
"full_module": "Vale.Lib.Map16",
"short_module": "Map16"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Stack_i",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.Heap",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Arch.HeapImpl",
"short_module": null
},
{
"abbrev": true,
"full_module": "Vale.PPC64LE.Memory",
"short_module": "M"
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE.Machine_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def.Prop_s",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.PPC64LE",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let eval_cmp_opr (o:cmp_opr) (s:state) : nat64 =
match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n | val eval_cmp_opr (o: cmp_opr) (s: state) : nat64
let eval_cmp_opr (o: cmp_opr) (s: state) : nat64 = | false | null | false | match o with
| CReg r -> eval_reg r s
| CImm n -> int_to_nat64 n | {
"checked_file": "Vale.PPC64LE.State.fsti.checked",
"dependencies": [
"Vale.PPC64LE.Vecs.fsti.checked",
"Vale.PPC64LE.Stack_Sems.fsti.checked",
"Vale.PPC64LE.Stack_i.fsti.checked",
"Vale.PPC64LE.Regs.fsti.checked",
"Vale.PPC64LE.Memory.fsti.checked",
"Vale.PPC64LE.Machine_s.fst.checked",
"Vale.Lib.Map16.fsti.checked",
"Vale.Def.Prop_s.fst.checked",
"Vale.Arch.HeapImpl.fsti.checked",
"Vale.Arch.Heap.fsti.checked",
"prims.fst.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.PPC64LE.State.fsti"
} | [
"total"
] | [
"Vale.PPC64LE.Machine_s.cmp_opr",
"Vale.PPC64LE.State.state",
"Vale.PPC64LE.Machine_s.reg",
"Vale.PPC64LE.State.eval_reg",
"Vale.PPC64LE.Machine_s.imm16",
"Vale.PPC64LE.Machine_s.int_to_nat64",
"Vale.PPC64LE.Machine_s.nat64"
] | [] | module Vale.PPC64LE.State
// This interface should not refer to Semantics_s
open Vale.Def.Prop_s
open Vale.PPC64LE.Machine_s
module M = Vale.PPC64LE.Memory
open Vale.Arch.HeapImpl
open Vale.Arch.Heap
open Vale.PPC64LE.Stack_i
module Map16 = Vale.Lib.Map16
module VSS = Vale.PPC64LE.Stack_Sems
val same_heap_types : squash (vale_full_heap == heap_impl)
unfold let coerce (#b #a:Type) (x:a{a == b}) : b = x
unfold let state = Vale.PPC64LE.Machine_s.state
[@va_qattr]
unfold let eval_reg (r:reg) (s:state) : nat64 = s.regs r
[@va_qattr]
unfold let eval_vec (v:vec) (s:state) : quad32 = s.vecs v
[@va_qattr]
unfold let eval_mem (ptr:int) (s:state) : GTot nat64 = M.load_mem64 ptr (M.get_vale_heap (coerce s.ms_heap))
[@va_qattr]
let eval_maddr (m:maddr) (s:state) : int =
eval_reg m.address s + m.offset
[@va_qattr] | false | true | Vale.PPC64LE.State.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val eval_cmp_opr (o: cmp_opr) (s: state) : nat64 | [] | Vale.PPC64LE.State.eval_cmp_opr | {
"file_name": "vale/code/arch/ppc64le/Vale.PPC64LE.State.fsti",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | o: Vale.PPC64LE.Machine_s.cmp_opr -> s: Vale.PPC64LE.State.state -> Vale.PPC64LE.Machine_s.nat64 | {
"end_col": 28,
"end_line": 33,
"start_col": 2,
"start_line": 31
} |
Prims.GTot | val rewrite_soundness
(#g:stt_env)
(#t:st_term)
(#c:comp)
(d:st_typing g t c{T_Rewrite? d})
: GTot (RT.tot_typing (elab_env g)
(elab_st_typing d)
(elab_comp c)) | [
{
"abbrev": true,
"full_module": "Pulse.Steel.Wrapper.Typing",
"short_module": "WT"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Checker.VPropEquiv",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Soundness.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing.Combinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Reflection.Util",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.Typing",
"short_module": "RT"
},
{
"abbrev": false,
"full_module": "Pulse.Soundness.Common",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Core",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Elaborate.Pure",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Typing",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Syntax",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Soundness",
"short_module": null
},
{
"abbrev": false,
"full_module": "Pulse.Soundness",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rewrite_soundness
(#g:stt_env)
(#t:st_term)
(#c:comp)
(d:st_typing g t c{T_Rewrite? d})
: GTot (RT.tot_typing (elab_env g)
(elab_st_typing d)
(elab_comp c)) =
let T_Rewrite _ p q p_typing equiv_p_q = d in
let rp = elab_term p in
let rq = elab_term q in
let rp_typing : RT.tot_typing _ rp vprop_tm =
tot_typing_soundness p_typing in
let rq_typing : RT.tot_typing _ rq vprop_tm =
tot_typing_soundness (let f, _ = vprop_equiv_typing equiv_p_q in
f p_typing) in
let d_stt_vprop_equiv =
Pulse.Soundness.VPropEquiv.vprop_equiv_unit_soundness
p_typing equiv_p_q in
WT.rewrite_typing rp_typing rq_typing d_stt_vprop_equiv | val rewrite_soundness
(#g:stt_env)
(#t:st_term)
(#c:comp)
(d:st_typing g t c{T_Rewrite? d})
: GTot (RT.tot_typing (elab_env g)
(elab_st_typing d)
(elab_comp c))
let rewrite_soundness (#g: stt_env) (#t: st_term) (#c: comp) (d: st_typing g t c {T_Rewrite? d})
: GTot (RT.tot_typing (elab_env g) (elab_st_typing d) (elab_comp c)) = | false | null | false | let T_Rewrite _ p q p_typing equiv_p_q = d in
let rp = elab_term p in
let rq = elab_term q in
let rp_typing:RT.tot_typing _ rp vprop_tm = tot_typing_soundness p_typing in
let rq_typing:RT.tot_typing _ rq vprop_tm =
tot_typing_soundness (let f, _ = vprop_equiv_typing equiv_p_q in
f p_typing)
in
let d_stt_vprop_equiv = Pulse.Soundness.VPropEquiv.vprop_equiv_unit_soundness p_typing equiv_p_q in
WT.rewrite_typing rp_typing rq_typing d_stt_vprop_equiv | {
"checked_file": "Pulse.Soundness.Rewrite.fst.checked",
"dependencies": [
"Pulse.Typing.Combinators.fsti.checked",
"Pulse.Typing.fst.checked",
"Pulse.Syntax.fst.checked",
"Pulse.Steel.Wrapper.Typing.fsti.checked",
"Pulse.Soundness.VPropEquiv.fsti.checked",
"Pulse.Soundness.Common.fst.checked",
"Pulse.Reflection.Util.fst.checked",
"Pulse.Elaborate.Pure.fst.checked",
"Pulse.Elaborate.Core.fst.checked",
"Pulse.Checker.VPropEquiv.fsti.checked",
"prims.fst.checked",
"FStar.Reflection.Typing.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": true,
"source_file": "Pulse.Soundness.Rewrite.fst"
} | [
"sometrivial"
] | [
"Pulse.Soundness.Common.stt_env",
"Pulse.Syntax.Base.st_term",
"Pulse.Syntax.Base.comp",
"Pulse.Typing.st_typing",
"Prims.b2t",
"Pulse.Typing.uu___is_T_Rewrite",
"Pulse.Typing.Env.env",
"Pulse.Syntax.Base.vprop",
"Pulse.Typing.tot_typing",
"Pulse.Syntax.Base.tm_vprop",
"Pulse.Typing.vprop_equiv",
"Pulse.Steel.Wrapper.Typing.rewrite_typing",
"Pulse.Typing.elab_env",
"FStar.Reflection.Typing.tot_typing",
"Pulse.Reflection.Util.stt_vprop_equiv",
"Pulse.Elaborate.Pure.elab_term",
"Pulse.Soundness.VPropEquiv.vprop_equiv_unit_soundness",
"Pulse.Reflection.Util.vprop_tm",
"Pulse.Soundness.Common.tot_typing_soundness",
"FStar.Pervasives.Native.tuple2",
"Pulse.Typing.Combinators.vprop_equiv_typing",
"FStar.Reflection.Types.term",
"Pulse.Elaborate.Core.elab_st_typing",
"Pulse.Elaborate.Pure.elab_comp"
] | [] | module Pulse.Soundness.Rewrite
open Pulse.Syntax
open Pulse.Reflection.Util
open Pulse.Typing
open Pulse.Typing.Combinators
open Pulse.Elaborate.Pure
open Pulse.Elaborate.Core
open Pulse.Soundness.Common
open Pulse.Checker.VPropEquiv
module RT = FStar.Reflection.Typing
module WT = Pulse.Steel.Wrapper.Typing
let rewrite_soundness
(#g:stt_env)
(#t:st_term)
(#c:comp)
(d:st_typing g t c{T_Rewrite? d})
: GTot (RT.tot_typing (elab_env g) | false | false | Pulse.Soundness.Rewrite.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rewrite_soundness
(#g:stt_env)
(#t:st_term)
(#c:comp)
(d:st_typing g t c{T_Rewrite? d})
: GTot (RT.tot_typing (elab_env g)
(elab_st_typing d)
(elab_comp c)) | [] | Pulse.Soundness.Rewrite.rewrite_soundness | {
"file_name": "lib/steel/pulse/Pulse.Soundness.Rewrite.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | d: Pulse.Typing.st_typing g t c {T_Rewrite? d}
-> Prims.GTot
(FStar.Reflection.Typing.tot_typing (Pulse.Typing.elab_env g)
(Pulse.Elaborate.Core.elab_st_typing d)
(Pulse.Elaborate.Pure.elab_comp c)) | {
"end_col": 57,
"end_line": 36,
"start_col": 25,
"start_line": 22
} |
FStar.Pervasives.Lemma | val lemma_nat_from_bytes_le_append (k1 k2: bytes)
: Lemma (requires Seq.length k1 + Seq.length k2 <= max_size_t)
(ensures
nat_from_bytes_le (Seq.append k1 k2) ==
nat_from_bytes_le k1 + pow2 (Seq.length k1 * 8) * nat_from_bytes_le k2) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": "S56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.BignumQ.Mul",
"short_module": "F56"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lemma_nat_from_bytes_le_append (k1 k2:bytes) : Lemma
(requires Seq.length k1 + Seq.length k2 <= max_size_t)
(ensures nat_from_bytes_le (Seq.append k1 k2) ==
nat_from_bytes_le k1 + pow2 (Seq.length k1 * 8) * nat_from_bytes_le k2) =
let k = Seq.append k1 k2 in
let n = Seq.length k1 + Seq.length k2 in
nat_from_intseq_le_slice_lemma #U8 #SEC #n k (Seq.length k1);
assert (k1 `Seq.equal` Seq.slice k 0 (Seq.length k1));
assert (k2 `Seq.equal` Seq.slice k (Seq.length k1) n) | val lemma_nat_from_bytes_le_append (k1 k2: bytes)
: Lemma (requires Seq.length k1 + Seq.length k2 <= max_size_t)
(ensures
nat_from_bytes_le (Seq.append k1 k2) ==
nat_from_bytes_le k1 + pow2 (Seq.length k1 * 8) * nat_from_bytes_le k2)
let lemma_nat_from_bytes_le_append (k1 k2: bytes)
: Lemma (requires Seq.length k1 + Seq.length k2 <= max_size_t)
(ensures
nat_from_bytes_le (Seq.append k1 k2) ==
nat_from_bytes_le k1 + pow2 (Seq.length k1 * 8) * nat_from_bytes_le k2) = | false | null | true | let k = Seq.append k1 k2 in
let n = Seq.length k1 + Seq.length k2 in
nat_from_intseq_le_slice_lemma #U8 #SEC #n k (Seq.length k1);
assert (k1 `Seq.equal` (Seq.slice k 0 (Seq.length k1)));
assert (k2 `Seq.equal` (Seq.slice k (Seq.length k1) n)) | {
"checked_file": "Hacl.Impl.Store56.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"Hacl.Impl.BignumQ.Mul.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Store56.fst"
} | [
"lemma"
] | [
"Lib.ByteSequence.bytes",
"Prims._assert",
"FStar.Seq.Base.equal",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"Prims.unit",
"Lib.ByteSequence.nat_from_intseq_le_slice_lemma",
"Prims.int",
"Prims.op_Addition",
"FStar.Seq.Base.seq",
"Lib.IntTypes.int_t",
"FStar.Seq.Base.append",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.max_size_t",
"Prims.squash",
"Prims.eq2",
"Lib.ByteSequence.nat_from_bytes_le",
"FStar.Mul.op_Star",
"Prims.pow2",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Hacl.Impl.Store56
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.ByteSequence
open Lib.Buffer
open Lib.ByteBuffer
module F56 = Hacl.Impl.BignumQ.Mul
module S56 = Hacl.Spec.BignumQ.Definitions
#reset-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextract
val hstore56_le:
out:lbuffer uint8 32ul
-> off:size_t{v off <= 21}
-> x:uint64{v x < pow2 56} ->
Stack unit
(requires fun h -> live h out)
(ensures fun h0 _ h1 -> modifies (loc (gsub out off 8ul)) h0 h1 /\
nat_from_bytes_le (Seq.slice (as_seq h1 out) (v off) (v off + 7)) == v x
)
let hstore56_le out off x =
let b8 = sub out off 8ul in
lemma_uint_to_bytes_le_preserves_value x;
uint_to_bytes_le b8 x;
let h1 = ST.get() in
calc (==) {
v x <: nat;
(==) { Math.Lemmas.small_mod (v x) (pow2 56) }
(v x) % pow2 56 <: nat;
(==) { assert (Seq.equal (as_seq h1 b8) (Seq.slice (as_seq h1 out) (v off) (v off + 8))) }
(nat_from_bytes_le (as_seq h1 b8)) % pow2 56;
(==) { nat_from_intseq_le_slice_lemma (as_seq h1 b8) 7 }
(nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7) +
pow2 56 * nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8)) % pow2 56;
(==) { Math.Lemmas.lemma_mod_plus_distr_r
(nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7))
(pow2 56 * nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8))
(pow2 56);
Math.Lemmas.swap_mul
(nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8))
(pow2 56);
Math.Lemmas.cancel_mul_mod
(nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8))
(pow2 56) }
nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7) % pow2 56;
(==) {
Math.Lemmas.small_mod (nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7)) (pow2 56);
assert (Seq.equal (Seq.slice (as_seq h1 b8) 0 7) (Seq.slice (as_seq h1 out) (v off) (v off + 7))) }
nat_from_bytes_le (Seq.slice (as_seq h1 out) (v off) (v off + 7));
}
let lemma_nat_from_bytes_le_append (k1 k2:bytes) : Lemma
(requires Seq.length k1 + Seq.length k2 <= max_size_t) | false | false | Hacl.Impl.Store56.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_nat_from_bytes_le_append (k1 k2: bytes)
: Lemma (requires Seq.length k1 + Seq.length k2 <= max_size_t)
(ensures
nat_from_bytes_le (Seq.append k1 k2) ==
nat_from_bytes_le k1 + pow2 (Seq.length k1 * 8) * nat_from_bytes_le k2) | [] | Hacl.Impl.Store56.lemma_nat_from_bytes_le_append | {
"file_name": "code/ed25519/Hacl.Impl.Store56.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | k1: Lib.ByteSequence.bytes -> k2: Lib.ByteSequence.bytes
-> FStar.Pervasives.Lemma
(requires FStar.Seq.Base.length k1 + FStar.Seq.Base.length k2 <= Lib.IntTypes.max_size_t)
(ensures
Lib.ByteSequence.nat_from_bytes_le (FStar.Seq.Base.append k1 k2) ==
Lib.ByteSequence.nat_from_bytes_le k1 +
Prims.pow2 (FStar.Seq.Base.length k1 * 8) * Lib.ByteSequence.nat_from_bytes_le k2) | {
"end_col": 55,
"end_line": 67,
"start_col": 75,
"start_line": 62
} |
FStar.HyperStack.ST.Stack | val hstore56_le:
out:lbuffer uint8 32ul
-> off:size_t{v off <= 21}
-> x:uint64{v x < pow2 56} ->
Stack unit
(requires fun h -> live h out)
(ensures fun h0 _ h1 -> modifies (loc (gsub out off 8ul)) h0 h1 /\
nat_from_bytes_le (Seq.slice (as_seq h1 out) (v off) (v off + 7)) == v x
) | [
{
"abbrev": true,
"full_module": "Hacl.Spec.BignumQ.Definitions",
"short_module": "S56"
},
{
"abbrev": true,
"full_module": "Hacl.Impl.BignumQ.Mul",
"short_module": "F56"
},
{
"abbrev": false,
"full_module": "Lib.ByteBuffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Buffer",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.HyperStack.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "ST"
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "Hacl.Impl",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let hstore56_le out off x =
let b8 = sub out off 8ul in
lemma_uint_to_bytes_le_preserves_value x;
uint_to_bytes_le b8 x;
let h1 = ST.get() in
calc (==) {
v x <: nat;
(==) { Math.Lemmas.small_mod (v x) (pow2 56) }
(v x) % pow2 56 <: nat;
(==) { assert (Seq.equal (as_seq h1 b8) (Seq.slice (as_seq h1 out) (v off) (v off + 8))) }
(nat_from_bytes_le (as_seq h1 b8)) % pow2 56;
(==) { nat_from_intseq_le_slice_lemma (as_seq h1 b8) 7 }
(nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7) +
pow2 56 * nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8)) % pow2 56;
(==) { Math.Lemmas.lemma_mod_plus_distr_r
(nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7))
(pow2 56 * nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8))
(pow2 56);
Math.Lemmas.swap_mul
(nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8))
(pow2 56);
Math.Lemmas.cancel_mul_mod
(nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8))
(pow2 56) }
nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7) % pow2 56;
(==) {
Math.Lemmas.small_mod (nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7)) (pow2 56);
assert (Seq.equal (Seq.slice (as_seq h1 b8) 0 7) (Seq.slice (as_seq h1 out) (v off) (v off + 7))) }
nat_from_bytes_le (Seq.slice (as_seq h1 out) (v off) (v off + 7));
} | val hstore56_le:
out:lbuffer uint8 32ul
-> off:size_t{v off <= 21}
-> x:uint64{v x < pow2 56} ->
Stack unit
(requires fun h -> live h out)
(ensures fun h0 _ h1 -> modifies (loc (gsub out off 8ul)) h0 h1 /\
nat_from_bytes_le (Seq.slice (as_seq h1 out) (v off) (v off + 7)) == v x
)
let hstore56_le out off x = | true | null | false | let b8 = sub out off 8ul in
lemma_uint_to_bytes_le_preserves_value x;
uint_to_bytes_le b8 x;
let h1 = ST.get () in
calc ( == ) {
v x <: nat;
( == ) { Math.Lemmas.small_mod (v x) (pow2 56) }
(v x) % pow2 56 <: nat;
( == ) { assert (Seq.equal (as_seq h1 b8) (Seq.slice (as_seq h1 out) (v off) (v off + 8))) }
(nat_from_bytes_le (as_seq h1 b8)) % pow2 56;
( == ) { nat_from_intseq_le_slice_lemma (as_seq h1 b8) 7 }
(nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7) +
pow2 56 * nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8)) %
pow2 56;
( == ) { (Math.Lemmas.lemma_mod_plus_distr_r (nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7))
(pow2 56 * nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8))
(pow2 56);
Math.Lemmas.swap_mul (nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8)) (pow2 56);
Math.Lemmas.cancel_mul_mod (nat_from_bytes_le (Seq.slice (as_seq h1 b8) 7 8)) (pow2 56)) }
nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7) % pow2 56;
( == ) { (Math.Lemmas.small_mod (nat_from_bytes_le (Seq.slice (as_seq h1 b8) 0 7)) (pow2 56);
assert (Seq.equal (Seq.slice (as_seq h1 b8) 0 7) (Seq.slice (as_seq h1 out) (v off) (v off + 7))
)) }
nat_from_bytes_le (Seq.slice (as_seq h1 out) (v off) (v off + 7));
} | {
"checked_file": "Hacl.Impl.Store56.fst.checked",
"dependencies": [
"prims.fst.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"Lib.ByteBuffer.fsti.checked",
"Lib.Buffer.fsti.checked",
"Hacl.Spec.BignumQ.Definitions.fst.checked",
"Hacl.Impl.BignumQ.Mul.fsti.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Math.Lemmas.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.All.fst.checked",
"FStar.Calc.fsti.checked"
],
"interface_file": false,
"source_file": "Hacl.Impl.Store56.fst"
} | [] | [
"Lib.Buffer.lbuffer",
"Lib.IntTypes.uint8",
"FStar.UInt32.__uint_to_t",
"Lib.IntTypes.size_t",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.IntTypes.v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.uint64",
"Prims.op_LessThan",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.pow2",
"FStar.Calc.calc_finish",
"Prims.nat",
"Prims.eq2",
"Lib.ByteSequence.nat_from_bytes_le",
"FStar.Seq.Base.slice",
"Lib.Buffer.as_seq",
"Lib.Buffer.MUT",
"Prims.op_Addition",
"Prims.Cons",
"FStar.Preorder.relation",
"Prims.Nil",
"Prims.unit",
"FStar.Calc.calc_step",
"Prims.op_Modulus",
"FStar.Mul.op_Star",
"FStar.Calc.calc_init",
"FStar.Calc.calc_pack",
"FStar.Math.Lemmas.small_mod",
"Prims.squash",
"Prims._assert",
"FStar.Seq.Base.equal",
"Lib.ByteSequence.nat_from_intseq_le_slice_lemma",
"Lib.IntTypes.U8",
"FStar.Math.Lemmas.cancel_mul_mod",
"FStar.Math.Lemmas.swap_mul",
"FStar.Math.Lemmas.lemma_mod_plus_distr_r",
"FStar.Monotonic.HyperStack.mem",
"FStar.HyperStack.ST.get",
"Lib.ByteBuffer.uint_to_bytes_le",
"Lib.ByteSequence.lemma_uint_to_bytes_le_preserves_value",
"Lib.Buffer.lbuffer_t",
"Lib.IntTypes.int_t",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.t",
"Lib.Buffer.sub"
] | [] | module Hacl.Impl.Store56
module ST = FStar.HyperStack.ST
open FStar.HyperStack.All
open FStar.Mul
open Lib.IntTypes
open Lib.ByteSequence
open Lib.Buffer
open Lib.ByteBuffer
module F56 = Hacl.Impl.BignumQ.Mul
module S56 = Hacl.Spec.BignumQ.Definitions
#reset-options "--z3rlimit 30 --max_fuel 0 --max_ifuel 0"
inline_for_extraction noextract
val hstore56_le:
out:lbuffer uint8 32ul
-> off:size_t{v off <= 21}
-> x:uint64{v x < pow2 56} ->
Stack unit
(requires fun h -> live h out)
(ensures fun h0 _ h1 -> modifies (loc (gsub out off 8ul)) h0 h1 /\
nat_from_bytes_le (Seq.slice (as_seq h1 out) (v off) (v off + 7)) == v x
) | false | false | Hacl.Impl.Store56.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 30,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val hstore56_le:
out:lbuffer uint8 32ul
-> off:size_t{v off <= 21}
-> x:uint64{v x < pow2 56} ->
Stack unit
(requires fun h -> live h out)
(ensures fun h0 _ h1 -> modifies (loc (gsub out off 8ul)) h0 h1 /\
nat_from_bytes_le (Seq.slice (as_seq h1 out) (v off) (v off + 7)) == v x
) | [] | Hacl.Impl.Store56.hstore56_le | {
"file_name": "code/ed25519/Hacl.Impl.Store56.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
out: Lib.Buffer.lbuffer Lib.IntTypes.uint8 32ul ->
off: Lib.IntTypes.size_t{Lib.IntTypes.v off <= 21} ->
x: Lib.IntTypes.uint64{Lib.IntTypes.v x < Prims.pow2 56}
-> FStar.HyperStack.ST.Stack Prims.unit | {
"end_col": 3,
"end_line": 57,
"start_col": 27,
"start_line": 28
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.