effect
stringclasses 48
values | original_source_type
stringlengths 0
23k
| opens_and_abbrevs
listlengths 2
92
| isa_cross_project_example
bool 1
class | source_definition
stringlengths 9
57.9k
| partial_definition
stringlengths 7
23.3k
| is_div
bool 2
classes | is_type
null | is_proof
bool 2
classes | completed_definiton
stringlengths 1
250k
| dependencies
dict | effect_flags
sequencelengths 0
2
| ideal_premises
sequencelengths 0
236
| mutual_with
sequencelengths 0
11
| file_context
stringlengths 0
407k
| interleaved
bool 1
class | is_simply_typed
bool 2
classes | file_name
stringlengths 5
48
| vconfig
dict | is_simple_lemma
null | source_type
stringlengths 10
23k
| proof_features
sequencelengths 0
1
| name
stringlengths 8
95
| source
dict | verbose_type
stringlengths 1
7.42k
| source_range
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Prims.Tot | val ttrue:pbool | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 ttrue : pbool = Ok () | val ttrue:pbool
let ttrue:pbool = | false | null | false | Ok () | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Vale.Def.PossiblyMonad.Ok",
"Prims.unit"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *) | false | true | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ttrue:pbool | [] | Vale.Def.PossiblyMonad.ttrue | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | Vale.Def.PossiblyMonad.possibly Prims.unit | {
"end_col": 25,
"end_line": 53,
"start_col": 20,
"start_line": 53
} |
Prims.Tot | val unimplemented (#a: Type) (s: string) : possibly a | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s) | val unimplemented (#a: Type) (s: string) : possibly a
let unimplemented (#a: Type) (s: string) : possibly a = | false | null | false | fail_with ("Unimplemented: " ^ s) | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Prims.string",
"Vale.Def.PossiblyMonad.fail_with",
"Prims.op_Hat",
"Vale.Def.PossiblyMonad.possibly"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s | false | false | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val unimplemented (#a: Type) (s: string) : possibly a | [] | Vale.Def.PossiblyMonad.unimplemented | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Prims.string -> Vale.Def.PossiblyMonad.possibly a | {
"end_col": 94,
"end_line": 21,
"start_col": 61,
"start_line": 21
} |
Prims.Tot | val fail_with (#a: Type) (s: string) : possibly a | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 fail_with (#a:Type) (s:string) : possibly a = Err s | val fail_with (#a: Type) (s: string) : possibly a
let fail_with (#a: Type) (s: string) : possibly a = | false | null | false | Err s | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Prims.string",
"Vale.Def.PossiblyMonad.Err",
"Vale.Def.PossiblyMonad.possibly"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x' | false | false | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val fail_with (#a: Type) (s: string) : possibly a | [] | Vale.Def.PossiblyMonad.fail_with | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Prims.string -> Vale.Def.PossiblyMonad.possibly a | {
"end_col": 62,
"end_line": 19,
"start_col": 57,
"start_line": 19
} |
Prims.Tot | val op_Bang_Bang (x: pbool) : bool | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 (!!) (x:pbool) : bool = Ok? x | val op_Bang_Bang (x: pbool) : bool
let op_Bang_Bang (x: pbool) : bool = | false | null | false | Ok? x | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Vale.Def.PossiblyMonad.pbool",
"Vale.Def.PossiblyMonad.uu___is_Ok",
"Prims.unit",
"Prims.bool"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *) | false | true | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Bang_Bang (x: pbool) : bool | [] | Vale.Def.PossiblyMonad.op_Bang_Bang | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.PossiblyMonad.pbool -> Prims.bool | {
"end_col": 33,
"end_line": 49,
"start_col": 28,
"start_line": 49
} |
Prims.Tot | val ffalse (reason: string) : pbool | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 ffalse (reason:string) : pbool = Err reason | val ffalse (reason: string) : pbool
let ffalse (reason: string) : pbool = | false | null | false | Err reason | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Prims.string",
"Vale.Def.PossiblyMonad.Err",
"Prims.unit",
"Vale.Def.PossiblyMonad.pbool"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *)
unfold
let ttrue : pbool = Ok ()
(** [ffalse] is the same as [false] but is for a [pbool] and thus requires a reason for being false. *) | false | true | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ffalse (reason: string) : pbool | [] | Vale.Def.PossiblyMonad.ffalse | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | reason: Prims.string -> Vale.Def.PossiblyMonad.pbool | {
"end_col": 47,
"end_line": 57,
"start_col": 37,
"start_line": 57
} |
Prims.Tot | val op_Slash_Subtraction (b: bool) (reason: string) : pbool | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 (/-) (b:bool) (reason:string) : pbool =
if b then
ttrue
else
ffalse reason | val op_Slash_Subtraction (b: bool) (reason: string) : pbool
let op_Slash_Subtraction (b: bool) (reason: string) : pbool = | false | null | false | if b then ttrue else ffalse reason | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Prims.bool",
"Prims.string",
"Vale.Def.PossiblyMonad.ttrue",
"Vale.Def.PossiblyMonad.ffalse",
"Vale.Def.PossiblyMonad.pbool"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *)
unfold
let ttrue : pbool = Ok ()
(** [ffalse] is the same as [false] but is for a [pbool] and thus requires a reason for being false. *)
unfold
let ffalse (reason:string) : pbool = Err reason
(** [b /- r] is the same as [b] but as a [pbool] that is set to reason [r] if [b] is false. *)
unfold | false | true | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Slash_Subtraction (b: bool) (reason: string) : pbool | [] | Vale.Def.PossiblyMonad.op_Slash_Subtraction | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | b: Prims.bool -> reason: Prims.string -> Vale.Def.PossiblyMonad.pbool | {
"end_col": 17,
"end_line": 65,
"start_col": 2,
"start_line": 62
} |
Prims.Tot | val op_let_Plus (#a #b: Type) (x: possibly a) (f: (a -> possibly b)) : possibly b | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x' | val op_let_Plus (#a #b: Type) (x: possibly a) (f: (a -> possibly b)) : possibly b
let op_let_Plus (#a #b: Type) (x: possibly a) (f: (a -> possibly b)) : possibly b = | false | null | false | match x with
| Err s -> Err s
| Ok x' -> f x' | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Vale.Def.PossiblyMonad.possibly",
"Prims.string",
"Vale.Def.PossiblyMonad.Err"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x | false | false | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_let_Plus (#a #b: Type) (x: possibly a) (f: (a -> possibly b)) : possibly b | [] | Vale.Def.PossiblyMonad.op_let_Plus | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.PossiblyMonad.possibly a -> f: (_: a -> Vale.Def.PossiblyMonad.possibly b)
-> Vale.Def.PossiblyMonad.possibly b | {
"end_col": 17,
"end_line": 17,
"start_col": 2,
"start_line": 15
} |
Prims.Tot | val loosen (#t1: Type) (#t2: Type{t1 `subtype_of` t2}) (x: possibly t1) : possibly t2 | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s | val loosen (#t1: Type) (#t2: Type{t1 `subtype_of` t2}) (x: possibly t1) : possibly t2
let loosen (#t1: Type) (#t2: Type{t1 `subtype_of` t2}) (x: possibly t1) : possibly t2 = | false | null | false | match x with
| Ok x' -> Ok x'
| Err s -> Err s | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Prims.subtype_of",
"Vale.Def.PossiblyMonad.possibly",
"Vale.Def.PossiblyMonad.Ok",
"Prims.string",
"Vale.Def.PossiblyMonad.Err"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2}) | false | false | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val loosen (#t1: Type) (#t2: Type{t1 `subtype_of` t2}) (x: possibly t1) : possibly t2 | [] | Vale.Def.PossiblyMonad.loosen | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.PossiblyMonad.possibly t1 -> Vale.Def.PossiblyMonad.possibly t2 | {
"end_col": 18,
"end_line": 29,
"start_col": 2,
"start_line": 27
} |
Prims.Tot | val op_Slash_Plus_Greater (p: pbool) (r: string) : pbool | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 (/+>) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (rr ^ r) | val op_Slash_Plus_Greater (p: pbool) (r: string) : pbool
let op_Slash_Plus_Greater (p: pbool) (r: string) : pbool = | false | null | false | match p with
| Ok () -> Ok ()
| Err rr -> Err (rr ^ r) | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Vale.Def.PossiblyMonad.pbool",
"Prims.string",
"Vale.Def.PossiblyMonad.Ok",
"Prims.unit",
"Vale.Def.PossiblyMonad.Err",
"Prims.op_Hat"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *)
unfold
let ttrue : pbool = Ok ()
(** [ffalse] is the same as [false] but is for a [pbool] and thus requires a reason for being false. *)
unfold
let ffalse (reason:string) : pbool = Err reason
(** [b /- r] is the same as [b] but as a [pbool] that is set to reason [r] if [b] is false. *)
unfold
let (/-) (b:bool) (reason:string) : pbool =
if b then
ttrue
else
ffalse reason
(** [p /+> r] is the same as [p] but also appends [r] to the reason if it was false. *)
unfold | false | true | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Slash_Plus_Greater (p: pbool) (r: string) : pbool | [] | Vale.Def.PossiblyMonad.op_Slash_Plus_Greater | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Vale.Def.PossiblyMonad.pbool -> r: Prims.string -> Vale.Def.PossiblyMonad.pbool | {
"end_col": 26,
"end_line": 72,
"start_col": 2,
"start_line": 70
} |
Prims.Tot | val for_all (f: ('a -> pbool)) (l: list 'a) : pbool | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 for_all (f : 'a -> pbool) (l : list 'a) : pbool =
match l with
| [] -> ttrue
| x :: xs -> f x &&. for_all f xs | val for_all (f: ('a -> pbool)) (l: list 'a) : pbool
let rec for_all (f: ('a -> pbool)) (l: list 'a) : pbool = | false | null | false | match l with
| [] -> ttrue
| x :: xs -> f x &&. for_all f xs | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Vale.Def.PossiblyMonad.pbool",
"Prims.list",
"Vale.Def.PossiblyMonad.ttrue",
"Vale.Def.PossiblyMonad.op_Amp_Amp_Dot",
"Vale.Def.PossiblyMonad.for_all"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *)
unfold
let ttrue : pbool = Ok ()
(** [ffalse] is the same as [false] but is for a [pbool] and thus requires a reason for being false. *)
unfold
let ffalse (reason:string) : pbool = Err reason
(** [b /- r] is the same as [b] but as a [pbool] that is set to reason [r] if [b] is false. *)
unfold
let (/-) (b:bool) (reason:string) : pbool =
if b then
ttrue
else
ffalse reason
(** [p /+> r] is the same as [p] but also appends [r] to the reason if it was false. *)
unfold
let (/+>) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (rr ^ r)
(** [p /+< r] is the same as [p] but also prepends [r] to the reason if it was false. *)
unfold
let (/+<) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (r ^ rr)
(** [&&.] is a short-circuiting logical-and. *)
let (&&.) (x y:pbool) : pbool =
match x with
| Ok () -> y
| Err reason -> Err reason
(** [ ||. ] is a short-circuiting logical-or *)
let ( ||. ) (x y:pbool) : pbool =
match x with
| Ok () -> Ok ()
| Err rx -> y /+< (rx ^ " and ")
(** [for_all f l] runs [f] on all the elements of [l] and performs a
short-circuit logical-and of all the results *) | false | false | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val for_all (f: ('a -> pbool)) (l: list 'a) : pbool | [
"recursion"
] | Vale.Def.PossiblyMonad.for_all | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: (_: 'a -> Vale.Def.PossiblyMonad.pbool) -> l: Prims.list 'a -> Vale.Def.PossiblyMonad.pbool | {
"end_col": 35,
"end_line": 98,
"start_col": 2,
"start_line": 96
} |
Prims.Tot | val tighten
(#t1: Type)
(#t2: Type{t2 `subtype_of` t1})
(x: possibly t1 {Ok? x ==> (Ok?.v x) `has_type` t2})
: possibly t2 | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s | val tighten
(#t1: Type)
(#t2: Type{t2 `subtype_of` t1})
(x: possibly t1 {Ok? x ==> (Ok?.v x) `has_type` t2})
: possibly t2
let tighten
(#t1: Type)
(#t2: Type{t2 `subtype_of` t1})
(x: possibly t1 {Ok? x ==> (Ok?.v x) `has_type` t2})
: possibly t2 = | false | null | false | match x with
| Ok x' -> Ok x'
| Err s -> Err s | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Prims.subtype_of",
"Vale.Def.PossiblyMonad.possibly",
"Prims.l_imp",
"Prims.b2t",
"Vale.Def.PossiblyMonad.uu___is_Ok",
"Prims.has_type",
"Vale.Def.PossiblyMonad.__proj__Ok__item__v",
"Vale.Def.PossiblyMonad.Ok",
"Prims.string",
"Vale.Def.PossiblyMonad.Err"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1}) | false | false | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val tighten
(#t1: Type)
(#t2: Type{t2 `subtype_of` t1})
(x: possibly t1 {Ok? x ==> (Ok?.v x) `has_type` t2})
: possibly t2 | [] | Vale.Def.PossiblyMonad.tighten | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.PossiblyMonad.possibly t1 {Ok? x ==> Prims.has_type (Ok?.v x) t2}
-> Vale.Def.PossiblyMonad.possibly t2 | {
"end_col": 18,
"end_line": 38,
"start_col": 2,
"start_line": 36
} |
Prims.Tot | val op_Amp_Amp_Dot (x y: pbool) : pbool | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 (&&.) (x y:pbool) : pbool =
match x with
| Ok () -> y
| Err reason -> Err reason | val op_Amp_Amp_Dot (x y: pbool) : pbool
let op_Amp_Amp_Dot (x y: pbool) : pbool = | false | null | false | match x with
| Ok () -> y
| Err reason -> Err reason | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Vale.Def.PossiblyMonad.pbool",
"Prims.string",
"Vale.Def.PossiblyMonad.Err",
"Prims.unit"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *)
unfold
let ttrue : pbool = Ok ()
(** [ffalse] is the same as [false] but is for a [pbool] and thus requires a reason for being false. *)
unfold
let ffalse (reason:string) : pbool = Err reason
(** [b /- r] is the same as [b] but as a [pbool] that is set to reason [r] if [b] is false. *)
unfold
let (/-) (b:bool) (reason:string) : pbool =
if b then
ttrue
else
ffalse reason
(** [p /+> r] is the same as [p] but also appends [r] to the reason if it was false. *)
unfold
let (/+>) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (rr ^ r)
(** [p /+< r] is the same as [p] but also prepends [r] to the reason if it was false. *)
unfold
let (/+<) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (r ^ rr)
(** [&&.] is a short-circuiting logical-and. *) | false | true | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Amp_Amp_Dot (x y: pbool) : pbool | [] | Vale.Def.PossiblyMonad.op_Amp_Amp_Dot | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.PossiblyMonad.pbool -> y: Vale.Def.PossiblyMonad.pbool -> Vale.Def.PossiblyMonad.pbool | {
"end_col": 28,
"end_line": 85,
"start_col": 2,
"start_line": 83
} |
Prims.Tot | val op_Slash_Plus_Less (p: pbool) (r: string) : pbool | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 (/+<) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (r ^ rr) | val op_Slash_Plus_Less (p: pbool) (r: string) : pbool
let op_Slash_Plus_Less (p: pbool) (r: string) : pbool = | false | null | false | match p with
| Ok () -> Ok ()
| Err rr -> Err (r ^ rr) | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Vale.Def.PossiblyMonad.pbool",
"Prims.string",
"Vale.Def.PossiblyMonad.Ok",
"Prims.unit",
"Vale.Def.PossiblyMonad.Err",
"Prims.op_Hat"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *)
unfold
let ttrue : pbool = Ok ()
(** [ffalse] is the same as [false] but is for a [pbool] and thus requires a reason for being false. *)
unfold
let ffalse (reason:string) : pbool = Err reason
(** [b /- r] is the same as [b] but as a [pbool] that is set to reason [r] if [b] is false. *)
unfold
let (/-) (b:bool) (reason:string) : pbool =
if b then
ttrue
else
ffalse reason
(** [p /+> r] is the same as [p] but also appends [r] to the reason if it was false. *)
unfold
let (/+>) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (rr ^ r)
(** [p /+< r] is the same as [p] but also prepends [r] to the reason if it was false. *)
unfold | false | true | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Slash_Plus_Less (p: pbool) (r: string) : pbool | [] | Vale.Def.PossiblyMonad.op_Slash_Plus_Less | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | p: Vale.Def.PossiblyMonad.pbool -> r: Prims.string -> Vale.Def.PossiblyMonad.pbool | {
"end_col": 26,
"end_line": 79,
"start_col": 2,
"start_line": 77
} |
Prims.Tot | val op_Bar_Bar_Dot (x y: pbool) : pbool | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": 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 ( ||. ) (x y:pbool) : pbool =
match x with
| Ok () -> Ok ()
| Err rx -> y /+< (rx ^ " and ") | val op_Bar_Bar_Dot (x y: pbool) : pbool
let op_Bar_Bar_Dot (x y: pbool) : pbool = | false | null | false | match x with
| Ok () -> Ok ()
| Err rx -> y /+< (rx ^ " and ") | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"total"
] | [
"Vale.Def.PossiblyMonad.pbool",
"Vale.Def.PossiblyMonad.Ok",
"Prims.unit",
"Prims.string",
"Vale.Def.PossiblyMonad.op_Slash_Plus_Less",
"Prims.op_Hat"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *)
unfold
let ttrue : pbool = Ok ()
(** [ffalse] is the same as [false] but is for a [pbool] and thus requires a reason for being false. *)
unfold
let ffalse (reason:string) : pbool = Err reason
(** [b /- r] is the same as [b] but as a [pbool] that is set to reason [r] if [b] is false. *)
unfold
let (/-) (b:bool) (reason:string) : pbool =
if b then
ttrue
else
ffalse reason
(** [p /+> r] is the same as [p] but also appends [r] to the reason if it was false. *)
unfold
let (/+>) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (rr ^ r)
(** [p /+< r] is the same as [p] but also prepends [r] to the reason if it was false. *)
unfold
let (/+<) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (r ^ rr)
(** [&&.] is a short-circuiting logical-and. *)
let (&&.) (x y:pbool) : pbool =
match x with
| Ok () -> y
| Err reason -> Err reason
(** [ ||. ] is a short-circuiting logical-or *) | false | true | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val op_Bar_Bar_Dot (x y: pbool) : pbool | [] | Vale.Def.PossiblyMonad.op_Bar_Bar_Dot | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Vale.Def.PossiblyMonad.pbool -> y: Vale.Def.PossiblyMonad.pbool -> Vale.Def.PossiblyMonad.pbool | {
"end_col": 34,
"end_line": 91,
"start_col": 2,
"start_line": 89
} |
FStar.Pervasives.Lemma | val lemma_for_all_elim (f: ('a -> pbool)) (l: list 'a)
: Lemma (requires !!(for_all f l))
(ensures (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x))) | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_for_all_elim (f : 'a -> pbool) (l : list 'a) :
Lemma
(requires !!(for_all f l))
(ensures (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x))) =
match l with
| [] -> ()
| x :: xs ->
lemma_for_all_elim f xs | val lemma_for_all_elim (f: ('a -> pbool)) (l: list 'a)
: Lemma (requires !!(for_all f l))
(ensures (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x)))
let rec lemma_for_all_elim (f: ('a -> pbool)) (l: list 'a)
: Lemma (requires !!(for_all f l))
(ensures (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x))) = | false | null | true | match l with
| [] -> ()
| x :: xs -> lemma_for_all_elim f xs | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"lemma"
] | [
"Vale.Def.PossiblyMonad.pbool",
"Prims.list",
"Vale.Def.PossiblyMonad.lemma_for_all_elim",
"Prims.unit",
"Prims.b2t",
"Vale.Def.PossiblyMonad.op_Bang_Bang",
"Vale.Def.PossiblyMonad.for_all",
"Prims.squash",
"Prims.l_Forall",
"Prims.l_imp",
"FStar.List.Tot.Base.memP",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *)
unfold
let ttrue : pbool = Ok ()
(** [ffalse] is the same as [false] but is for a [pbool] and thus requires a reason for being false. *)
unfold
let ffalse (reason:string) : pbool = Err reason
(** [b /- r] is the same as [b] but as a [pbool] that is set to reason [r] if [b] is false. *)
unfold
let (/-) (b:bool) (reason:string) : pbool =
if b then
ttrue
else
ffalse reason
(** [p /+> r] is the same as [p] but also appends [r] to the reason if it was false. *)
unfold
let (/+>) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (rr ^ r)
(** [p /+< r] is the same as [p] but also prepends [r] to the reason if it was false. *)
unfold
let (/+<) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (r ^ rr)
(** [&&.] is a short-circuiting logical-and. *)
let (&&.) (x y:pbool) : pbool =
match x with
| Ok () -> y
| Err reason -> Err reason
(** [ ||. ] is a short-circuiting logical-or *)
let ( ||. ) (x y:pbool) : pbool =
match x with
| Ok () -> Ok ()
| Err rx -> y /+< (rx ^ " and ")
(** [for_all f l] runs [f] on all the elements of [l] and performs a
short-circuit logical-and of all the results *)
let rec for_all (f : 'a -> pbool) (l : list 'a) : pbool =
match l with
| [] -> ttrue
| x :: xs -> f x &&. for_all f xs
(** Change from a [forall] to a [for_all] *)
let rec lemma_for_all_intro (f : 'a -> pbool) (l : list 'a) :
Lemma
(requires (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x)))
(ensures !!(for_all f l)) =
let open FStar.List.Tot in
let aux l x :
Lemma
(requires (x `memP` l ==> !!(f x)))
(ensures (Cons? l /\ x `memP` tl l ==> !!(f x))) = () in
match l with
| [] -> ()
| x :: xs ->
FStar.Classical.forall_intro (FStar.Classical.move_requires (aux l));
lemma_for_all_intro f xs
(** Change from a [for_all] to a [forall] *)
let rec lemma_for_all_elim (f : 'a -> pbool) (l : list 'a) :
Lemma
(requires !!(for_all f l)) | false | false | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_for_all_elim (f: ('a -> pbool)) (l: list 'a)
: Lemma (requires !!(for_all f l))
(ensures (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x))) | [
"recursion"
] | Vale.Def.PossiblyMonad.lemma_for_all_elim | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: (_: 'a -> Vale.Def.PossiblyMonad.pbool) -> l: Prims.list 'a
-> FStar.Pervasives.Lemma (requires !!(Vale.Def.PossiblyMonad.for_all f l))
(ensures
forall (x: 'a). {:pattern FStar.List.Tot.Base.memP x l}
FStar.List.Tot.Base.memP x l ==> !!(f x)) | {
"end_col": 27,
"end_line": 124,
"start_col": 2,
"start_line": 121
} |
FStar.Pervasives.Lemma | val lemma_for_all_intro (f: ('a -> pbool)) (l: list 'a)
: Lemma
(requires (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x)))
(ensures !!(for_all f l)) | [
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "Vale.Def",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let rec lemma_for_all_intro (f : 'a -> pbool) (l : list 'a) :
Lemma
(requires (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x)))
(ensures !!(for_all f l)) =
let open FStar.List.Tot in
let aux l x :
Lemma
(requires (x `memP` l ==> !!(f x)))
(ensures (Cons? l /\ x `memP` tl l ==> !!(f x))) = () in
match l with
| [] -> ()
| x :: xs ->
FStar.Classical.forall_intro (FStar.Classical.move_requires (aux l));
lemma_for_all_intro f xs | val lemma_for_all_intro (f: ('a -> pbool)) (l: list 'a)
: Lemma
(requires (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x)))
(ensures !!(for_all f l))
let rec lemma_for_all_intro (f: ('a -> pbool)) (l: list 'a)
: Lemma
(requires (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x)))
(ensures !!(for_all f l)) = | false | null | true | let open FStar.List.Tot in
let aux l x
: Lemma (requires (x `memP` l ==> !!(f x))) (ensures (Cons? l /\ x `memP` (tl l) ==> !!(f x))) =
()
in
match l with
| [] -> ()
| x :: xs ->
FStar.Classical.forall_intro (FStar.Classical.move_requires (aux l));
lemma_for_all_intro f xs | {
"checked_file": "Vale.Def.PossiblyMonad.fst.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "Vale.Def.PossiblyMonad.fst"
} | [
"lemma"
] | [
"Vale.Def.PossiblyMonad.pbool",
"Prims.list",
"Vale.Def.PossiblyMonad.lemma_for_all_intro",
"Prims.unit",
"FStar.Classical.forall_intro",
"Prims.l_imp",
"FStar.List.Tot.Base.memP",
"Prims.b2t",
"Vale.Def.PossiblyMonad.op_Bang_Bang",
"Prims.l_and",
"Prims.uu___is_Cons",
"FStar.List.Tot.Base.tl",
"FStar.Classical.move_requires",
"Vale.Def.PossiblyMonad.uu___is_Ok",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"Prims.l_Forall",
"Vale.Def.PossiblyMonad.for_all"
] | [] | module Vale.Def.PossiblyMonad
/// Similar to the [maybe] monad in Haskell (which is like the
/// [option] type in F* and OCaml), but instead, we also store the
/// reason for the error when the error occurs.
type possibly 'a =
| Ok : v:'a -> possibly 'a
| Err : reason:string -> possibly 'a
unfold let return (#a:Type) (x:a) : possibly a =
Ok x
unfold let (let+) (#a #b:Type) (x:possibly a) (f:a -> possibly b) : possibly b =
match x with
| Err s -> Err s
| Ok x' -> f x'
unfold let fail_with (#a:Type) (s:string) : possibly a = Err s
unfold let unimplemented (#a:Type) (s:string) : possibly a = fail_with ("Unimplemented: " ^ s)
(** Allows moving to a "looser" monad type, always *)
unfold
let loosen (#t1:Type) (#t2:Type{t1 `subtype_of` t2})
(x:possibly t1) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** Allows moving to a "tighter" monad type, as long as the monad is
guaranteed statically to be within this tighter type *)
unfold
let tighten (#t1:Type) (#t2:Type{t2 `subtype_of` t1})
(x:possibly t1{Ok? x ==> Ok?.v x `has_type` t2}) : possibly t2 =
match x with
| Ok x' -> Ok x'
| Err s -> Err s
(** [pbool] is a type that can be used instead of [bool] to hold on to
a reason whenever it is [false]. To convert from a [pbool] to a
bool, see [!!]. *)
unfold
type pbool = possibly unit
(** [!!x] coerces a [pbool] into a [bool] by discarding any reason it
holds on to and instead uses it solely as a boolean. *)
unfold
let (!!) (x:pbool) : bool = Ok? x
(** [ttrue] is just the same as [true] but for a [pbool] *)
unfold
let ttrue : pbool = Ok ()
(** [ffalse] is the same as [false] but is for a [pbool] and thus requires a reason for being false. *)
unfold
let ffalse (reason:string) : pbool = Err reason
(** [b /- r] is the same as [b] but as a [pbool] that is set to reason [r] if [b] is false. *)
unfold
let (/-) (b:bool) (reason:string) : pbool =
if b then
ttrue
else
ffalse reason
(** [p /+> r] is the same as [p] but also appends [r] to the reason if it was false. *)
unfold
let (/+>) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (rr ^ r)
(** [p /+< r] is the same as [p] but also prepends [r] to the reason if it was false. *)
unfold
let (/+<) (p:pbool) (r:string) : pbool =
match p with
| Ok () -> Ok ()
| Err rr -> Err (r ^ rr)
(** [&&.] is a short-circuiting logical-and. *)
let (&&.) (x y:pbool) : pbool =
match x with
| Ok () -> y
| Err reason -> Err reason
(** [ ||. ] is a short-circuiting logical-or *)
let ( ||. ) (x y:pbool) : pbool =
match x with
| Ok () -> Ok ()
| Err rx -> y /+< (rx ^ " and ")
(** [for_all f l] runs [f] on all the elements of [l] and performs a
short-circuit logical-and of all the results *)
let rec for_all (f : 'a -> pbool) (l : list 'a) : pbool =
match l with
| [] -> ttrue
| x :: xs -> f x &&. for_all f xs
(** Change from a [forall] to a [for_all] *)
let rec lemma_for_all_intro (f : 'a -> pbool) (l : list 'a) :
Lemma
(requires (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x))) | false | false | Vale.Def.PossiblyMonad.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 0,
"max_fuel": 1,
"max_ifuel": 1,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": true,
"smtencoding_l_arith_repr": "native",
"smtencoding_nl_arith_repr": "wrapped",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [
"smt.arith.nl=false",
"smt.QI.EAGER_THRESHOLD=100",
"smt.CASE_SPLIT=3"
],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val lemma_for_all_intro (f: ('a -> pbool)) (l: list 'a)
: Lemma
(requires (forall x. {:pattern (x `List.Tot.memP` l)} (x `List.Tot.memP` l) ==> !!(f x)))
(ensures !!(for_all f l)) | [
"recursion"
] | Vale.Def.PossiblyMonad.lemma_for_all_intro | {
"file_name": "vale/specs/defs/Vale.Def.PossiblyMonad.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | f: (_: 'a -> Vale.Def.PossiblyMonad.pbool) -> l: Prims.list 'a
-> FStar.Pervasives.Lemma
(requires
forall (x: 'a). {:pattern FStar.List.Tot.Base.memP x l}
FStar.List.Tot.Base.memP x l ==> !!(f x)) (ensures !!(Vale.Def.PossiblyMonad.for_all f l)) | {
"end_col": 28,
"end_line": 114,
"start_col": 2,
"start_line": 105
} |
Prims.GTot | val swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v | val swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t = | false | null | false | Ghost.reveal w.v | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.swriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.__proj__SWriter__item__v"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0) | false | false | LowParse.Low.Writers.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 swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t | [] | LowParse.Low.Writers.swvalue | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0 -> Prims.GTot t | {
"end_col": 18,
"end_line": 65,
"start_col": 2,
"start_line": 65
} |
Prims.GTot | val wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v | val wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t = | false | null | false | Ghost.reveal w.v | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.__proj__Writer__item__v"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t | [] | LowParse.Low.Writers.wvalue | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.writer s h0 sout pout_from0 -> Prims.GTot t | {
"end_col": 18,
"end_line": 191,
"start_col": 2,
"start_line": 191
} |
Prims.GTot | val lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v | val lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t) = | false | null | false | Ghost.reveal w.v | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"FStar.Ghost.reveal",
"Prims.list",
"LowParse.Low.Writers.__proj__LWriter__item__v"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t) | [] | LowParse.Low.Writers.lwvalue | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.lwriter s h0 sout pout_from0 -> Prims.GTot (Prims.list t) | {
"end_col": 18,
"end_line": 321,
"start_col": 2,
"start_line": 321
} |
Prims.GTot | val olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v | val olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t)) = | false | null | false | Ghost.reveal w.v | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.olwriter",
"FStar.Ghost.reveal",
"Prims.list",
"LowParse.Low.Writers.__proj__OLWriter__item__v"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t)) | [] | LowParse.Low.Writers.olwvalue | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.olwriter s h0 sout pout_from0
-> Prims.GTot (FStar.Pervasives.Native.option (Prims.list t)) | {
"end_col": 18,
"end_line": 708,
"start_col": 2,
"start_line": 708
} |
Prims.GTot | val grvalue
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r) | val grvalue
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
let grvalue
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t = | false | null | false | Ghost.reveal (GReader?.v r) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"sometrivial"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.__proj__GReader__item__v"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t) | false | false | LowParse.Low.Writers.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 grvalue
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t | [] | LowParse.Low.Writers.grvalue | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | r: LowParse.Low.Writers.greader h0 sout pout_from0 t -> Prims.GTot t | {
"end_col": 29,
"end_line": 932,
"start_col": 2,
"start_line": 932
} |
Prims.GTot | val owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v | val owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t) = | false | null | false | Ghost.reveal w.v | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"sometrivial"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.owriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.__proj__OWriter__item__v"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t) | [] | LowParse.Low.Writers.owvalue | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.owriter s h0 sout pout_from0
-> Prims.GTot (FStar.Pervasives.Native.option t) | {
"end_col": 18,
"end_line": 561,
"start_col": 2,
"start_line": 561
} |
Prims.Tot | val lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f | val lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w)) = | false | null | false | match w with | LWriter _ f -> f | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"FStar.Ghost.erased",
"Prims.list",
"LowParse.Low.Writers.flwriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.lwvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w)) | [] | LowParse.Low.Writers.lwrite | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.lwriter s h0 sout pout_from0
-> LowParse.Low.Writers.flwriter s h0 sout pout_from0 (LowParse.Low.Writers.lwvalue w) | {
"end_col": 33,
"end_line": 353,
"start_col": 2,
"start_line": 353
} |
Prims.Pure | val weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w': swriter s h1 space_beyond1 sout pout_from1 {swvalue w' == swvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\
space_beyond0 <= space_beyond1))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from) | val weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w': swriter s h1 space_beyond1 sout pout_from1 {swvalue w' == swvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\
space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w': swriter s h1 space_beyond1 sout pout_from1 {swvalue w' == swvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\
space_beyond0 <= space_beyond1))
(ensures (fun _ -> True)) = | false | null | false | SWriter w.v (fun pout_from -> w.w pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.swriter",
"LowParse.Low.Writers.SWriter",
"LowParse.Low.Writers.__proj__SWriter__item__v",
"LowParse.Low.Writers.__proj__SWriter__item__w",
"LowParse.Low.Writers.swvalue",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1)) | false | false | LowParse.Low.Writers.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 weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w': swriter s h1 space_beyond1 sout pout_from1 {swvalue w' == swvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\
space_beyond0 <= space_beyond1))
(ensures (fun _ -> True)) | [] | LowParse.Low.Writers.weaken_swriter | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w: LowParse.Low.Writers.swriter s h0 space_beyond0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
space_beyond1: Prims.nat ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.swriter s h1 space_beyond1 sout pout_from1
{LowParse.Low.Writers.swvalue w' == LowParse.Low.Writers.swvalue w}) | {
"end_col": 46,
"end_line": 85,
"start_col": 2,
"start_line": 85
} |
Prims.Tot | val lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == []}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
) | val lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == []})
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == []}) = | false | null | false | LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"Prims.Nil",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list_nil",
"FStar.HyperStack.ST.get",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.lwvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t) | false | false | LowParse.Low.Writers.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 lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == []}) | [] | LowParse.Low.Writers.lwriter_nil | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_low k > 0 } ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t
-> x: LowParse.Low.Writers.lwriter s h0 sout pout_from0 {LowParse.Low.Writers.lwvalue x == []} | {
"end_col": 3,
"end_line": 371,
"start_col": 2,
"start_line": 366
} |
Prims.Tot | val write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f | val write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w)) = | false | null | false | match w with | Writer _ f -> f | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"FStar.Ghost.erased",
"LowParse.Low.Writers.fwriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.wvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w)) | [] | LowParse.Low.Writers.write | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.writer s h0 sout pout_from0
-> LowParse.Low.Writers.fwriter s h0 sout pout_from0 (LowParse.Low.Writers.wvalue w) | {
"end_col": 32,
"end_line": 223,
"start_col": 2,
"start_line": 223
} |
Prims.Pure | val weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': owriter s h1 sout pout_from1 {owvalue w' == owvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from) | val weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': owriter s h1 sout pout_from1 {owvalue w' == owvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': owriter s h1 sout pout_from1 {owvalue w' == owvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) = | false | null | false | OWriter w.v (fun pout_from -> w.w pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.OWriter",
"LowParse.Low.Writers.__proj__OWriter__item__v",
"LowParse.Low.Writers.__proj__OWriter__item__w",
"LowParse.Low.Writers.owvalue",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1)) | false | false | LowParse.Low.Writers.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 weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': owriter s h1 sout pout_from1 {owvalue w' == owvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | [] | LowParse.Low.Writers.weaken_owriter | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w: LowParse.Low.Writers.owriter s h0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.owriter s h1 sout pout_from1
{LowParse.Low.Writers.owvalue w' == LowParse.Low.Writers.owvalue w}) | {
"end_col": 46,
"end_line": 579,
"start_col": 2,
"start_line": 579
} |
Prims.Tot | val owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f | val owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w)) = | false | null | false | match w with | OWriter _ f -> f | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.owriter",
"FStar.Ghost.erased",
"LowParse.Low.Writers.fowriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.owvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w)) | [] | LowParse.Low.Writers.owrite | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.owriter s h0 sout pout_from0
-> LowParse.Low.Writers.fowriter s h0 sout pout_from0 (LowParse.Low.Writers.owvalue w) | {
"end_col": 33,
"end_line": 593,
"start_col": 2,
"start_line": 593
} |
Prims.Pure | val weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': writer s h1 sout pout_from1 {wvalue w' == wvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from) | val weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': writer s h1 sout pout_from1 {wvalue w' == wvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': writer s h1 sout pout_from1 {wvalue w' == wvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) = | false | null | false | Writer w.v (fun pout_from -> w.w pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.Writer",
"LowParse.Low.Writers.__proj__Writer__item__v",
"LowParse.Low.Writers.__proj__Writer__item__w",
"LowParse.Low.Writers.wvalue",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1)) | false | false | LowParse.Low.Writers.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 weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': writer s h1 sout pout_from1 {wvalue w' == wvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | [] | LowParse.Low.Writers.weaken_writer | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w: LowParse.Low.Writers.writer s h0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.writer s h1 sout pout_from1
{LowParse.Low.Writers.wvalue w' == LowParse.Low.Writers.wvalue w}) | {
"end_col": 45,
"end_line": 209,
"start_col": 2,
"start_line": 209
} |
Prims.Pure | val weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': lwriter s h1 sout pout_from1 {lwvalue w' == lwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from) | val weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': lwriter s h1 sout pout_from1 {lwvalue w' == lwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': lwriter s h1 sout pout_from1 {lwvalue w' == lwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) = | false | null | false | LWriter w.v (fun pout_from -> w.w pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.LWriter",
"LowParse.Low.Writers.__proj__LWriter__item__v",
"LowParse.Low.Writers.__proj__LWriter__item__w",
"Prims.list",
"LowParse.Low.Writers.lwvalue",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1)) | false | false | LowParse.Low.Writers.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 weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': lwriter s h1 sout pout_from1 {lwvalue w' == lwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | [] | LowParse.Low.Writers.weaken_lwriter | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w: LowParse.Low.Writers.lwriter s h0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.lwriter s h1 sout pout_from1
{LowParse.Low.Writers.lwvalue w' == LowParse.Low.Writers.lwvalue w}) | {
"end_col": 46,
"end_line": 339,
"start_col": 2,
"start_line": 339
} |
Prims.Tot | val swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f | val swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w)) = | false | null | false | match w with | SWriter _ f -> f | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.nat",
"LowParse.Low.Writers.swriter",
"FStar.Ghost.erased",
"LowParse.Low.Writers.fswriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.swvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0) | false | false | LowParse.Low.Writers.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 swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w)) | [] | LowParse.Low.Writers.swrite | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0
-> LowParse.Low.Writers.fswriter s
h0
space_beyond
sout
pout_from0
(LowParse.Low.Writers.swvalue w) | {
"end_col": 33,
"end_line": 100,
"start_col": 2,
"start_line": 100
} |
Prims.Tot | val swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 {swvalue y == x}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from) | val swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 {swvalue y == x})
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 {swvalue y == x}) = | false | null | false | SWriter (Ghost.hide x) (fun pout_from -> w x sout pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.leaf_writer_strong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.SWriter",
"FStar.Ghost.hide",
"LowParse.Low.Writers.swriter",
"LowParse.Low.Writers.swvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t) | false | false | LowParse.Low.Writers.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 swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 {swvalue y == x}) | [] | LowParse.Low.Writers.swrite_leaf | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w: LowParse.Low.Base.leaf_writer_strong s ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
x: t
-> y: LowParse.Low.Writers.swriter s h0 0 sout pout_from0 {LowParse.Low.Writers.swvalue y == x} | {
"end_col": 39,
"end_line": 134,
"start_col": 2,
"start_line": 133
} |
Prims.Tot | val swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot
(x:
swriter s h0 space_beyond sout pout_from0
{swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ()))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from) | val swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot
(x:
swriter s h0 space_beyond sout pout_from0
{swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ()))})
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot
(x:
swriter s h0 space_beyond sout pout_from0
{swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ()))}) = | false | null | false | SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.swriter",
"LowParse.Low.Writers.SWriter",
"LowParse.Low.Writers.__proj__SWriter__item__v",
"FStar.Ghost.erased",
"LowParse.Low.Writers.swrite",
"LowParse.Low.Writers.swvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0))) | false | false | LowParse.Low.Writers.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 swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot
(x:
swriter s h0 space_beyond sout pout_from0
{swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ()))}) | [] | LowParse.Low.Writers.swriter_ifthenelse | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cond: Prims.bool ->
wtrue:
(_: Prims.squash (cond == true)
-> LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0) ->
wfalse:
(_: Prims.squash (cond == false)
-> LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0)
-> x:
LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0
{ LowParse.Low.Writers.swvalue x ==
(match cond with
| true -> LowParse.Low.Writers.swvalue (wtrue ())
| _ -> LowParse.Low.Writers.swvalue (wfalse ())) } | {
"end_col": 95,
"end_line": 118,
"start_col": 2,
"start_line": 117
} |
Prims.Tot | val olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f | val olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w)) = | false | null | false | match w with | OLWriter _ f -> f | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.olwriter",
"FStar.Ghost.erased",
"Prims.list",
"LowParse.Low.Writers.folwriter",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.olwvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w)) | [] | LowParse.Low.Writers.olwrite | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.olwriter s h0 sout pout_from0
-> LowParse.Low.Writers.folwriter s h0 sout pout_from0 (LowParse.Low.Writers.olwvalue w) | {
"end_col": 34,
"end_line": 740,
"start_col": 2,
"start_line": 740
} |
Prims.Tot | val write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 {wvalue y == x}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
) | val write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 {wvalue y == x})
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 {wvalue y == x}) = | false | null | false | Writer (Ghost.hide x)
(fun pout_from ->
if (U32.uint_to_t k.parser_kind_low) `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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.nat",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"Prims.b2t",
"Prims.op_LessThan",
"LowParse.Low.Base.leaf_writer_strong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.Writer",
"FStar.Ghost.hide",
"FStar.UInt32.gt",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.sub",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.ErrorCode.max_uint32",
"Prims.bool",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.wvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t) | false | false | LowParse.Low.Writers.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 write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 {wvalue y == x}) | [] | LowParse.Low.Writers.write_leaf_cs | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w: LowParse.Low.Base.leaf_writer_strong s ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
x: t
-> y: LowParse.Low.Writers.writer s h0 sout pout_from0 {LowParse.Low.Writers.wvalue y == x} | {
"end_col": 3,
"end_line": 260,
"start_col": 2,
"start_line": 255
} |
Prims.Tot | val owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 {owvalue x == Some (wvalue w)}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from) | val owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 {owvalue x == Some (wvalue w)})
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 {owvalue x == Some (wvalue w)}) = | false | null | false | OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.OWriter",
"FStar.Ghost.hide",
"LowParse.Low.Writers.wvalue",
"LowParse.Low.Writers.write",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.owvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 {owvalue x == Some (wvalue w)}) | [] | LowParse.Low.Writers.owriter_of_writer | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.writer s h0 sout pout_from0
-> x:
LowParse.Low.Writers.owriter s h0 sout pout_from0
{ LowParse.Low.Writers.owvalue x ==
FStar.Pervasives.Native.Some (LowParse.Low.Writers.wvalue w) } | {
"end_col": 77,
"end_line": 644,
"start_col": 2,
"start_line": 644
} |
Prims.Tot | val lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == [wvalue w]}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
) | val lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == [wvalue w]})
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == [wvalue w]}) = | false | null | false | LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
else
([@@ inline_let ]let f ()
: Lemma
(ensures
(let v = wvalue w in
serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ());
res) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"Prims.Cons",
"LowParse.Low.Writers.wvalue",
"Prims.Nil",
"Prims.unit",
"FStar.UInt32.lt",
"LowParse.Low.ErrorCode.max_uint32",
"LowParse.Low.Base.Spec.valid_list_cons",
"LowParse.Low.Base.Spec.valid_list_nil",
"FStar.HyperStack.ST.get",
"Prims.bool",
"Prims.l_True",
"Prims.squash",
"Prims.nat",
"LowParse.Low.Base.Spec.serialized_list_length",
"LowParse.Low.Base.Spec.serialized_length",
"FStar.Pervasives.pattern",
"LowParse.Low.Base.Spec.serialized_list_length_nil",
"LowParse.Low.Base.Spec.serialized_list_length_cons",
"LowParse.Low.Writers.write",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.lwvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 {lwvalue x == [wvalue w]}) | [] | LowParse.Low.Writers.lwriter_singleton | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.writer s h0 sout pout_from0
-> x:
LowParse.Low.Writers.lwriter s h0 sout pout_from0
{LowParse.Low.Writers.lwvalue x == [LowParse.Low.Writers.wvalue w]} | {
"end_col": 3,
"end_line": 402,
"start_col": 2,
"start_line": 385
} |
Prims.Tot | val greader_tot
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t {grvalue r == x}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x) | val greader_tot
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t {grvalue r == x})
let greader_tot
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t {grvalue r == x}) = | false | null | false | GReader (Ghost.hide x) (fun _ -> x) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"Prims.unit",
"LowParse.Low.Writers.greader",
"Prims.eq2",
"LowParse.Low.Writers.grvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction
noextract
let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t) | false | false | LowParse.Low.Writers.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 greader_tot
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t {grvalue r == x}) | [] | LowParse.Low.Writers.greader_tot | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
x: t
-> r: LowParse.Low.Writers.greader h0 sout pout_from0 t {LowParse.Low.Writers.grvalue r == x} | {
"end_col": 37,
"end_line": 1060,
"start_col": 2,
"start_line": 1060
} |
Prims.Pure | val weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': olwriter s h1 sout pout_from1 {olwvalue w' == olwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from) | val weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': olwriter s h1 sout pout_from1 {olwvalue w' == olwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': olwriter s h1 sout pout_from1 {olwvalue w' == olwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) = | false | null | false | OLWriter w.v (fun pout_from -> w.w pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.OLWriter",
"LowParse.Low.Writers.__proj__OLWriter__item__v",
"LowParse.Low.Writers.__proj__OLWriter__item__w",
"Prims.list",
"LowParse.Low.Writers.olwvalue",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"Prims.l_True"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1)) | false | false | LowParse.Low.Writers.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 weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w': olwriter s h1 sout pout_from1 {olwvalue w' == olwvalue w})
(requires
(B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True)) | [] | LowParse.Low.Writers.weaken_olwriter | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w: LowParse.Low.Writers.olwriter s h0 sout pout_from0 ->
h1: FStar.Monotonic.HyperStack.mem ->
pout_from1: FStar.UInt32.t
-> Prims.Pure
(w':
LowParse.Low.Writers.olwriter s h1 sout pout_from1
{LowParse.Low.Writers.olwvalue w' == LowParse.Low.Writers.olwvalue w}) | {
"end_col": 47,
"end_line": 726,
"start_col": 2,
"start_line": 726
} |
Prims.Tot | val writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot
(x:
writer s h0 sout pout_from0
{wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ()))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from) | val writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot
(x:
writer s h0 sout pout_from0
{wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ()))})
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot
(x:
writer s h0 sout pout_from0
{wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ()))}) = | false | null | false | Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.Writer",
"LowParse.Low.Writers.__proj__Writer__item__v",
"FStar.Ghost.erased",
"LowParse.Low.Writers.write",
"LowParse.Low.Writers.wvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0))) | false | false | LowParse.Low.Writers.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 writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot
(x:
writer s h0 sout pout_from0
{wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ()))}) | [] | LowParse.Low.Writers.writer_ifthenelse | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cond: Prims.bool ->
wtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.writer s h0 sout pout_from0) ->
wfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.writer s h0 sout pout_from0)
-> x:
LowParse.Low.Writers.writer s h0 sout pout_from0
{ LowParse.Low.Writers.wvalue x ==
(match cond with
| true -> LowParse.Low.Writers.wvalue (wtrue ())
| _ -> LowParse.Low.Writers.wvalue (wfalse ())) } | {
"end_col": 93,
"end_line": 240,
"start_col": 2,
"start_line": 239
} |
Prims.Tot | val wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (writer s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': writer s h0 sout pout_from0 {wvalue w' == wvalue (w (grvalue r))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
) | val wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (writer s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': writer s h0 sout pout_from0 {wvalue w' == wvalue (w (grvalue r))})
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (writer s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': writer s h0 sout pout_from0 {wvalue w' == wvalue (w (grvalue r))}) = | false | null | false | Writer (Ghost.hide (wvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
write (w v) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.Writer",
"FStar.Ghost.hide",
"LowParse.Low.Writers.wvalue",
"LowParse.Low.Writers.write",
"LowParse.Low.Writers.gread"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True)))) | false | false | LowParse.Low.Writers.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 wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (writer s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': writer s h0 sout pout_from0 {wvalue w' == wvalue (w (grvalue r))}) | [] | LowParse.Low.Writers.wbind | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.writer s h0 sout pout_from0))
-> w':
LowParse.Low.Writers.writer s h0 sout pout_from0
{ LowParse.Low.Writers.wvalue w' ==
LowParse.Low.Writers.wvalue (w (LowParse.Low.Writers.grvalue r)) } | {
"end_col": 3,
"end_line": 990,
"start_col": 2,
"start_line": 987
} |
Prims.Tot | val owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (owriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': owriter s h0 sout pout_from0 {owvalue w' == owvalue (w (grvalue r))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
) | val owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (owriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': owriter s h0 sout pout_from0 {owvalue w' == owvalue (w (grvalue r))})
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (owriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': owriter s h0 sout pout_from0 {owvalue w' == owvalue (w (grvalue r))}) = | false | null | false | OWriter (Ghost.hide (owvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
owrite (w v) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.OWriter",
"FStar.Ghost.hide",
"LowParse.Low.Writers.owvalue",
"LowParse.Low.Writers.owrite",
"LowParse.Low.Writers.gread"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True)))) | false | false | LowParse.Low.Writers.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 owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (owriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': owriter s h0 sout pout_from0 {owvalue w' == owvalue (w (grvalue r))}) | [] | LowParse.Low.Writers.owbind | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.owriter s h0 sout pout_from0))
-> w':
LowParse.Low.Writers.owriter s h0 sout pout_from0
{ LowParse.Low.Writers.owvalue w' ==
LowParse.Low.Writers.owvalue (w (LowParse.Low.Writers.grvalue r)) } | {
"end_col": 3,
"end_line": 1009,
"start_col": 2,
"start_line": 1006
} |
Prims.Tot | val olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from) | val olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0) = | false | null | false | OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.OLWriter",
"FStar.Ghost.hide",
"Prims.list",
"LowParse.Low.Writers.lwvalue",
"LowParse.Low.Writers.lwrite",
"LowParse.Low.Writers.olwriter"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0) | [] | LowParse.Low.Writers.olwriter_of_lwriter | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.lwriter s h0 sout pout_from0
-> LowParse.Low.Writers.olwriter s h0 sout pout_from0 | {
"end_col": 80,
"end_line": 852,
"start_col": 2,
"start_line": 852
} |
Prims.Tot | val grifthenelse
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t)))
: Tot
(r':
greader h0 sout pout_from0 t
{grvalue r' == (if cond then grvalue (grtrue ()) else grvalue (grfalse ()))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let grifthenelse
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t)))
: Tot (r' : greader h0 sout pout_from0 t { grvalue r' == (if cond then grvalue (grtrue ()) else grvalue (grfalse ())) } )
= GReader (Ghost.hide (if cond then grvalue (grtrue ()) else grvalue (grfalse ()))) (fun _ ->
if cond then gread (grtrue ()) else gread (grfalse ())
) | val grifthenelse
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t)))
: Tot
(r':
greader h0 sout pout_from0 t
{grvalue r' == (if cond then grvalue (grtrue ()) else grvalue (grfalse ()))})
let grifthenelse
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t)))
: Tot
(r':
greader h0 sout pout_from0 t
{grvalue r' == (if cond then grvalue (grtrue ()) else grvalue (grfalse ()))}) = | false | null | false | GReader (Ghost.hide (if cond then grvalue (grtrue ()) else grvalue (grfalse ())))
(fun _ -> if cond then gread (grtrue ()) else gread (grfalse ())) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"Prims.eq2",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"LowParse.Low.Writers.grvalue",
"Prims.unit",
"LowParse.Low.Writers.gread"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction
noextract
let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x)
inline_for_extraction
noextract
let graccess
(#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)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\
valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r: greader h0 sout pout_from0 U32.t { grvalue r == slice_access h0 g sin pin } )
= GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ ->
a sin pin
)
inline_for_extraction
noextract
let read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 t { grvalue r' == contents p h0 sin pin } )
= GReader (Ghost.hide (contents p h0 sin pin)) (fun _ ->
r sin pin
)
inline_for_extraction
noextract
let grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool)) // should be GTot, but List.find requires Tot
(f' : (
(#rrel: _) ->
(#rel: _) ->
(sl: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack bool
(requires (fun h ->
valid p h sl pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (contents p h sl pos)
))
))
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 bool { grvalue r' == L.existsb f (contents_list p h0 sl pos pos') } )
= GReader (Ghost.hide (L.existsb f (contents_list p h0 sl pos pos'))) (fun _ ->
list_existsb j f f' sl pos pos'
)
inline_for_extraction
noextract
let grifthenelse
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t))) | false | false | LowParse.Low.Writers.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 grifthenelse
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(cond: bool)
(grtrue: (squash (cond == true) -> Tot (greader h0 sout pout_from0 t)))
(grfalse: (squash (cond == false) -> Tot (greader h0 sout pout_from0 t)))
: Tot
(r':
greader h0 sout pout_from0 t
{grvalue r' == (if cond then grvalue (grtrue ()) else grvalue (grfalse ()))}) | [] | LowParse.Low.Writers.grifthenelse | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cond: Prims.bool ->
grtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.greader h0 sout pout_from0 t) ->
grfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.greader h0 sout pout_from0 t)
-> r':
LowParse.Low.Writers.greader h0 sout pout_from0 t
{ LowParse.Low.Writers.grvalue r' ==
(match cond with
| true -> LowParse.Low.Writers.grvalue (grtrue ())
| _ -> LowParse.Low.Writers.grvalue (grfalse ())) } | {
"end_col": 3,
"end_line": 1163,
"start_col": 2,
"start_line": 1161
} |
FStar.HyperStack.ST.Stack | val gread
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h -> B.modifies (loc_slice_from sout pout_from0) h0 h))
(ensures (fun h res h' -> B.modifies B.loc_none h h' /\ res == grvalue r)) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f () | val gread
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h -> B.modifies (loc_slice_from sout pout_from0) h0 h))
(ensures (fun h res h' -> B.modifies B.loc_none h h' /\ res == grvalue r))
let gread
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h -> B.modifies (loc_slice_from sout pout_from0) h0 h))
(ensures (fun h res h' -> B.modifies B.loc_none h h' /\ res == grvalue r)) = | true | null | false | match r with | GReader _ f -> f () | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [] | [
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"FStar.Ghost.erased",
"Prims.unit",
"LowStar.Monotonic.Buffer.modifies",
"LowParse.Slice.loc_slice_from",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_none",
"Prims.eq2",
"FStar.Ghost.reveal",
"LowParse.Low.Writers.grvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r | false | false | LowParse.Low.Writers.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 gread
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h -> B.modifies (loc_slice_from sout pout_from0) h0 h))
(ensures (fun h res h' -> B.modifies B.loc_none h h' /\ res == grvalue r)) | [] | LowParse.Low.Writers.gread | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | r: LowParse.Low.Writers.greader h0 sout pout_from0 t -> FStar.HyperStack.ST.Stack t | {
"end_col": 23,
"end_line": 951,
"start_col": 2,
"start_line": 950
} |
Prims.Pure | val olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (olwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r)))) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
) | val olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (olwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (olwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r)))) = | false | null | false | OLWriter (Ghost.hide (olwvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
olwrite (w v) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.OLWriter",
"FStar.Ghost.hide",
"Prims.list",
"LowParse.Low.Writers.olwvalue",
"LowParse.Low.Writers.olwrite",
"LowParse.Low.Writers.gread"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True) | false | false | LowParse.Low.Writers.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 olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (olwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r)))) | [] | LowParse.Low.Writers.olwbind | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.olwriter s h0 sout pout_from0))
-> Prims.Pure (LowParse.Low.Writers.olwriter s h0 sout pout_from0) | {
"end_col": 3,
"end_line": 1049,
"start_col": 2,
"start_line": 1046
} |
Prims.Tot | val lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot
(x:
lwriter s h0 sout pout_from0
{lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ()))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from) | val lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot
(x:
lwriter s h0 sout pout_from0
{lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ()))})
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot
(x:
lwriter s h0 sout pout_from0
{lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ()))}) = | false | null | false | LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.LWriter",
"LowParse.Low.Writers.__proj__LWriter__item__v",
"FStar.Ghost.erased",
"Prims.list",
"LowParse.Low.Writers.lwrite",
"LowParse.Low.Writers.lwvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0))) | false | false | LowParse.Low.Writers.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 lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot
(x:
lwriter s h0 sout pout_from0
{lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ()))}) | [] | LowParse.Low.Writers.lwriter_ifthenelse | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cond: Prims.bool ->
wtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.lwriter s h0 sout pout_from0) ->
wfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.lwriter s h0 sout pout_from0)
-> x:
LowParse.Low.Writers.lwriter s h0 sout pout_from0
{ LowParse.Low.Writers.lwvalue x ==
(match cond with
| true -> LowParse.Low.Writers.lwvalue (wtrue ())
| _ -> LowParse.Low.Writers.lwvalue (wfalse ())) } | {
"end_col": 95,
"end_line": 451,
"start_col": 2,
"start_line": 450
} |
Prims.Tot | val owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot
(x:
owriter s h0 sout pout_from0
{owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ()))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from) | val owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot
(x:
owriter s h0 sout pout_from0
{owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ()))})
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot
(x:
owriter s h0 sout pout_from0
{owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ()))}) = | false | null | false | OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.OWriter",
"LowParse.Low.Writers.__proj__OWriter__item__v",
"FStar.Ghost.erased",
"LowParse.Low.Writers.owrite",
"LowParse.Low.Writers.owvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0))) | false | false | LowParse.Low.Writers.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 owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot
(x:
owriter s h0 sout pout_from0
{owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ()))}) | [] | LowParse.Low.Writers.owriter_ifthenelse | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cond: Prims.bool ->
wtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.owriter s h0 sout pout_from0) ->
wfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.owriter s h0 sout pout_from0)
-> x:
LowParse.Low.Writers.owriter s h0 sout pout_from0
{ LowParse.Low.Writers.owvalue x ==
(match cond with
| true -> LowParse.Low.Writers.owvalue (wtrue ())
| _ -> LowParse.Low.Writers.owvalue (wfalse ())) } | {
"end_col": 95,
"end_line": 610,
"start_col": 2,
"start_line": 609
} |
Prims.Tot | val olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot
(x:
olwriter s h0 sout pout_from0
{olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ()))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from) | val olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot
(x:
olwriter s h0 sout pout_from0
{olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ()))})
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot
(x:
olwriter s h0 sout pout_from0
{olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ()))}) = | false | null | false | OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"Prims.bool",
"Prims.squash",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.OLWriter",
"LowParse.Low.Writers.__proj__OLWriter__item__v",
"FStar.Ghost.erased",
"Prims.list",
"LowParse.Low.Writers.olwrite",
"LowParse.Low.Writers.olwvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0))) | false | false | LowParse.Low.Writers.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 olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot
(x:
olwriter s h0 sout pout_from0
{olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ()))}) | [] | LowParse.Low.Writers.olwriter_ifthenelse | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cond: Prims.bool ->
wtrue: (_: Prims.squash (cond == true) -> LowParse.Low.Writers.olwriter s h0 sout pout_from0) ->
wfalse: (_: Prims.squash (cond == false) -> LowParse.Low.Writers.olwriter s h0 sout pout_from0)
-> x:
LowParse.Low.Writers.olwriter s h0 sout pout_from0
{ LowParse.Low.Writers.olwvalue x ==
(match cond with
| true -> LowParse.Low.Writers.olwvalue (wtrue ())
| _ -> LowParse.Low.Writers.olwvalue (wfalse ())) } | {
"end_col": 97,
"end_line": 838,
"start_col": 2,
"start_line": 837
} |
Prims.Tot | val swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (swriter s h0 space_beyond sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': swriter s h0 space_beyond sout pout_from0 {swvalue w' == swvalue (w (grvalue r))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
) | val swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (swriter s h0 space_beyond sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': swriter s h0 space_beyond sout pout_from0 {swvalue w' == swvalue (w (grvalue r))})
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (swriter s h0 space_beyond sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': swriter s h0 space_beyond sout pout_from0 {swvalue w' == swvalue (w (grvalue r))}) = | false | null | false | SWriter (Ghost.hide (swvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
swrite (w v) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"FStar.Monotonic.HyperStack.mem",
"Prims.nat",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.swriter",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.SWriter",
"FStar.Ghost.hide",
"LowParse.Low.Writers.swvalue",
"LowParse.Low.Writers.swrite",
"LowParse.Low.Writers.gread"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True)))) | false | false | LowParse.Low.Writers.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 swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#h0: HS.mem)
(#space_beyond: nat)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (swriter s h0 space_beyond sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': swriter s h0 space_beyond sout pout_from0 {swvalue w' == swvalue (w (grvalue r))}) | [] | LowParse.Low.Writers.swbind | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0))
-> w':
LowParse.Low.Writers.swriter s h0 space_beyond sout pout_from0
{ LowParse.Low.Writers.swvalue w' ==
LowParse.Low.Writers.swvalue (w (LowParse.Low.Writers.grvalue r)) } | {
"end_col": 3,
"end_line": 971,
"start_col": 2,
"start_line": 968
} |
Prims.Tot | val lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (lwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': lwriter s h0 sout pout_from0 {lwvalue w' == lwvalue (w (grvalue r))}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
) | val lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (lwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': lwriter s h0 sout pout_from0 {lwvalue w' == lwvalue (w (grvalue r))})
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (lwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': lwriter s h0 sout pout_from0 {lwvalue w' == lwvalue (w (grvalue r))}) = | false | null | false | LWriter (Ghost.hide (lwvalue (w (grvalue r))))
(fun pout_from ->
let v = gread r in
lwrite (w v) pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.grvalue",
"Prims.l_True",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"LowParse.Low.Writers.lwvalue",
"LowParse.Low.Writers.lwrite",
"LowParse.Low.Writers.gread"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True)))) | false | false | LowParse.Low.Writers.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 lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w:
(x: tr
-> Pure (lwriter s h0 sout pout_from0)
(requires (x == grvalue r))
(ensures (fun _ -> True))))
: Tot (w': lwriter s h0 sout pout_from0 {lwvalue w' == lwvalue (w (grvalue r))}) | [] | LowParse.Low.Writers.lwbind | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
r: LowParse.Low.Writers.greader h0 sout pout_from0 tr ->
w: (x: tr -> Prims.Pure (LowParse.Low.Writers.lwriter s h0 sout pout_from0))
-> w':
LowParse.Low.Writers.lwriter s h0 sout pout_from0
{ LowParse.Low.Writers.lwvalue w' ==
LowParse.Low.Writers.lwvalue (w (LowParse.Low.Writers.grvalue r)) } | {
"end_col": 3,
"end_line": 1028,
"start_col": 2,
"start_line": 1025
} |
Prims.Tot | val wcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ B.loc_disjoint (loc_slice_from_to sin pin_from pin_to)
(loc_slice_from sout sout_from0) /\ valid_pos p h0 sin pin_from pin_to })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
) | val wcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ B.loc_disjoint (loc_slice_from_to sin pin_from pin_to)
(loc_slice_from sout sout_from0) /\ valid_pos p h0 sin pin_from pin_to })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from})
let wcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ B.loc_disjoint (loc_slice_from_to sin pin_from pin_to)
(loc_slice_from sout sout_from0) /\ valid_pos p h0 sin pin_from pin_to })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from}) = | false | null | false | Writer (Ghost.hide (contents p h0 sin pin_from))
(fun sout_from -> copy_weak_with_length p sin pin_from pin_to sout sout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Slice.loc_slice_from",
"LowParse.Low.Base.Spec.valid_pos",
"LowParse.Low.Writers.Writer",
"FStar.Ghost.hide",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.copy_weak_with_length",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.wvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from | false | false | LowParse.Low.Writers.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 wcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ B.loc_disjoint (loc_slice_from_to sin pin_from pin_to)
(loc_slice_from sout sout_from0) /\ valid_pos p h0 sin pin_from pin_to })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from}) | [] | LowParse.Low.Writers.wcopy | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
sin: LowParse.Slice.slice rrel rel ->
pin_from: FStar.UInt32.t ->
pin_to: FStar.UInt32.t ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
sout_from0: FStar.UInt32.t ->
h0:
FStar.Monotonic.HyperStack.mem
{ LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sin
pin_from
pin_to)
(LowParse.Slice.loc_slice_from sout sout_from0) /\
LowParse.Low.Base.Spec.valid_pos p h0 sin pin_from pin_to }
-> w:
LowParse.Low.Writers.writer s h0 sout sout_from0
{LowParse.Low.Writers.wvalue w == LowParse.Low.Base.Spec.contents p h0 sin pin_from} | {
"end_col": 3,
"end_line": 875,
"start_col": 2,
"start_line": 873
} |
Prims.Tot | val lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot
(x: lwriter s h0 sout pout_from0 {lwvalue x == (lwvalue w1) `List.Tot.append` (lwvalue w2)}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
) | val lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot
(x: lwriter s h0 sout pout_from0 {lwvalue x == (lwvalue w1) `List.Tot.append` (lwvalue w2)})
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot
(x: lwriter s h0 sout pout_from0 {lwvalue x == (lwvalue w1) `List.Tot.append` (lwvalue w2)}) = | false | null | false | LWriter (Ghost.hide ((lwvalue w1) `List.Tot.append` (lwvalue w2)))
(fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then res1
else
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then
(valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2);
res2) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"FStar.List.Tot.Base.append",
"LowParse.Low.Writers.lwvalue",
"Prims.op_Equality",
"LowParse.Low.ErrorCode.max_uint32",
"Prims.bool",
"Prims.unit",
"FStar.UInt32.lt",
"LowParse.Low.Base.Spec.valid_list_serialized_list_length",
"LowParse.Low.Base.Spec.valid_list_append",
"FStar.HyperStack.ST.get",
"LowParse.Low.Writers.lwrite",
"FStar.Classical.forall_intro_2",
"Prims.int",
"LowParse.Low.Base.Spec.serialized_list_length",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.serialized_list_length_append"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot
(x: lwriter s h0 sout pout_from0 {lwvalue x == (lwvalue w1) `List.Tot.append` (lwvalue w2)}) | [] | LowParse.Low.Writers.lwriter_append | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w1: LowParse.Low.Writers.lwriter s h0 sout pout_from0 ->
w2: LowParse.Low.Writers.lwriter s h0 sout pout_from0
-> x:
LowParse.Low.Writers.lwriter s h0 sout pout_from0
{ LowParse.Low.Writers.lwvalue x ==
LowParse.Low.Writers.lwvalue w1 @ LowParse.Low.Writers.lwvalue w2 } | {
"end_col": 3,
"end_line": 434,
"start_col": 2,
"start_line": 416
} |
Prims.Tot | val read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r': greader h0 sout pout_from0 t {grvalue r' == contents p h0 sin pin}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 t { grvalue r' == contents p h0 sin pin } )
= GReader (Ghost.hide (contents p h0 sin pin)) (fun _ ->
r sin pin
) | val read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r': greader h0 sout pout_from0 t {grvalue r' == contents p h0 sin pin})
let read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r': greader h0 sout pout_from0 t {grvalue r' == contents p h0 sin pin}) = | false | null | false | GReader (Ghost.hide (contents p h0 sin pin)) (fun _ -> r sin pin) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.leaf_reader",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"FStar.Monotonic.HyperStack.mem",
"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.valid",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Slice.loc_slice_from",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"LowParse.Low.Base.Spec.contents",
"Prims.unit",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.grvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction
noextract
let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x)
inline_for_extraction
noextract
let graccess
(#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)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\
valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r: greader h0 sout pout_from0 U32.t { grvalue r == slice_access h0 g sin pin } )
= GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ ->
a sin pin
)
inline_for_extraction
noextract
let read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin)) (loc_slice_from sout pout_from0)
}) | false | false | LowParse.Low.Writers.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r': greader h0 sout pout_from0 t {grvalue r' == contents p h0 sin pin}) | [] | LowParse.Low.Writers.read_leaf | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
r: LowParse.Low.Base.leaf_reader p ->
sin: LowParse.Slice.slice rrel rel ->
pin: FStar.UInt32.t ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
h0:
FStar.Monotonic.HyperStack.mem
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid p h0 sin pin /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sin
pin
(LowParse.Low.Base.Spec.get_valid_pos p h0 sin pin))
(LowParse.Slice.loc_slice_from sout pout_from0) }
-> r':
LowParse.Low.Writers.greader h0 sout pout_from0 t
{LowParse.Low.Writers.grvalue r' == LowParse.Low.Base.Spec.contents p h0 sin pin} | {
"end_col": 3,
"end_line": 1111,
"start_col": 2,
"start_line": 1109
} |
Prims.Tot | val wjcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from))
(loc_slice_from sout sout_from0) })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
) | val wjcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from))
(loc_slice_from sout sout_from0) })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from})
let wjcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from))
(loc_slice_from sout sout_from0) })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from}) = | false | null | false | Writer (Ghost.hide (contents p h0 sin pin_from))
(fun sout_from -> copy_weak p j sin pin_from sout sout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"LowParse.Spec.Base.parser_subkind",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_subkind",
"FStar.Pervasives.Native.Some",
"LowParse.Spec.Base.ParserStrong",
"LowParse.Low.Base.jumper",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"FStar.Monotonic.HyperStack.mem",
"Prims.l_and",
"LowParse.Low.Base.Spec.valid",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Slice.loc_slice_from",
"LowParse.Low.Writers.Writer",
"FStar.Ghost.hide",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Base.copy_weak",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.wvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from | false | false | LowParse.Low.Writers.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 wjcopy
(#k #t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0:
HS.mem
{ valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from))
(loc_slice_from sout sout_from0) })
: Tot (w: writer s h0 sout sout_from0 {wvalue w == contents p h0 sin pin_from}) | [] | LowParse.Low.Writers.wjcopy | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong } ->
j: LowParse.Low.Base.jumper p ->
sin: LowParse.Slice.slice rrel rel ->
pin_from: FStar.UInt32.t ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
sout_from0: FStar.UInt32.t ->
h0:
FStar.Monotonic.HyperStack.mem
{ LowParse.Low.Base.Spec.valid p h0 sin pin_from /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sin
pin_from
(LowParse.Low.Base.Spec.get_valid_pos p h0 sin pin_from))
(LowParse.Slice.loc_slice_from sout sout_from0) }
-> w:
LowParse.Low.Writers.writer s h0 sout sout_from0
{LowParse.Low.Writers.wvalue w == LowParse.Low.Base.Spec.contents p h0 sin pin_from} | {
"end_col": 3,
"end_line": 899,
"start_col": 2,
"start_line": 897
} |
Prims.Tot | val graccess
(#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)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\ valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r: greader h0 sout pout_from0 U32.t {grvalue r == slice_access h0 g sin pin}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let graccess
(#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)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\
valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r: greader h0 sout pout_from0 U32.t { grvalue r == slice_access h0 g sin pin } )
= GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ ->
a sin pin
) | val graccess
(#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)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\ valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r: greader h0 sout pout_from0 U32.t {grvalue r == slice_access h0 g sin pin})
let graccess
(#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)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\ valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r: greader h0 sout pout_from0 U32.t {grvalue r == slice_access h0 g sin pin}) = | false | null | false | GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ -> a sin pin) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.Spec.clens",
"LowParse.Low.Base.Spec.gaccessor",
"LowParse.Low.Base.accessor",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"FStar.Monotonic.HyperStack.mem",
"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.valid",
"LowParse.Low.Base.Spec.__proj__Mkclens__item__clens_cond",
"LowParse.Low.Base.Spec.contents",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.get_valid_pos",
"LowParse.Slice.loc_slice_from",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"LowParse.Low.Base.Spec.slice_access",
"Prims.unit",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.grvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction
noextract
let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x)
inline_for_extraction
noextract
let graccess
(#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)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\
valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin)) (loc_slice_from sout pout_from0)
}) | false | false | LowParse.Low.Writers.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 graccess
(#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)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\ valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin))
(loc_slice_from sout pout_from0) })
: Tot (r: greader h0 sout pout_from0 U32.t {grvalue r == slice_access h0 g sin pin}) | [] | LowParse.Low.Writers.graccess | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
a: LowParse.Low.Base.accessor g ->
sin: LowParse.Slice.slice rrel rel ->
pin: FStar.UInt32.t ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
h0:
FStar.Monotonic.HyperStack.mem
{ Mkparser_kind'?.parser_kind_subkind k1 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_subkind k2 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid p1 h0 sin pin /\
Mkclens?.clens_cond cl (LowParse.Low.Base.Spec.contents p1 h0 sin pin) /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sin
pin
(LowParse.Low.Base.Spec.get_valid_pos p1 h0 sin pin))
(LowParse.Slice.loc_slice_from sout pout_from0) }
-> r:
LowParse.Low.Writers.greader h0 sout pout_from0 FStar.UInt32.t
{LowParse.Low.Writers.grvalue r == LowParse.Low.Base.Spec.slice_access h0 g sin pin} | {
"end_col": 3,
"end_line": 1089,
"start_col": 2,
"start_line": 1087
} |
Prims.Tot | val owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 {owvalue y == Some x}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
) | val owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 {owvalue y == Some x})
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 {owvalue y == Some x}) = | false | null | false | OWriter (Ghost.hide (Some x))
(fun pout_from ->
if (U32.uint_to_t k.parser_kind_low) `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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.nat",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"Prims.b2t",
"Prims.op_LessThan",
"LowParse.Low.Base.leaf_writer_strong",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.OWriter",
"FStar.Ghost.hide",
"FStar.UInt32.gt",
"FStar.UInt32.uint_to_t",
"FStar.UInt32.sub",
"LowParse.Slice.__proj__Mkslice__item__len",
"LowParse.Low.ErrorCode.max_uint32",
"Prims.bool",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.owvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t) | false | false | LowParse.Low.Writers.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 owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s:
serializer p
{ k.parser_kind_subkind == Some ParserStrong /\
k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 })
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 {owvalue y == Some x}) | [] | LowParse.Low.Writers.owrite_leaf_cs | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w: LowParse.Low.Base.leaf_writer_strong s ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
x: t
-> y:
LowParse.Low.Writers.owriter s h0 sout pout_from0
{LowParse.Low.Writers.owvalue y == FStar.Pervasives.Native.Some x} | {
"end_col": 3,
"end_line": 630,
"start_col": 2,
"start_line": 625
} |
Prims.Tot | val olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match olwvalue w1, olwvalue w2 with
| Some l1, Some l2 -> Some (l1 `List.Tot.append` l2)
| _ -> None) }) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
) | val olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match olwvalue w1, olwvalue w2 with
| Some l1, Some l2 -> Some (l1 `List.Tot.append` l2)
| _ -> None) })
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match olwvalue w1, olwvalue w2 with
| Some l1, Some l2 -> Some (l1 `List.Tot.append` l2)
| _ -> None) }) = | false | null | false | OLWriter
(Ghost.hide (match olwvalue w1, olwvalue w2 with
| Some l1, Some l2 -> Some (l1 `List.Tot.append` l2)
| _ -> None))
(fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then res1
else
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then
(valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2);
res2) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.OLWriter",
"FStar.Ghost.hide",
"Prims.list",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Low.Writers.olwvalue",
"FStar.List.Tot.Base.append",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.None",
"FStar.UInt32.lte",
"FStar.UInt32.sub",
"LowParse.Low.ErrorCode.max_uint32",
"FStar.UInt32.__uint_to_t",
"Prims.bool",
"Prims.unit",
"FStar.UInt32.lt",
"LowParse.Low.Base.Spec.valid_list_serialized_list_length",
"LowParse.Low.Base.Spec.valid_list_append",
"FStar.HyperStack.ST.get",
"LowParse.Low.Writers.olwrite",
"FStar.Classical.forall_intro_2",
"Prims.int",
"LowParse.Low.Base.Spec.serialized_list_length",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.serialized_list_length_append"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match olwvalue w1, olwvalue w2 with
| Some l1, Some l2 -> Some (l1 `List.Tot.append` l2)
| _ -> None) }) | [] | LowParse.Low.Writers.olwriter_append | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
w1: LowParse.Low.Writers.olwriter s h0 sout pout_from0 ->
w2: LowParse.Low.Writers.olwriter s h0 sout pout_from0
-> x:
LowParse.Low.Writers.olwriter s h0 sout pout_from0
{ LowParse.Low.Writers.olwvalue x ==
(match LowParse.Low.Writers.olwvalue w1, LowParse.Low.Writers.olwvalue w2 with
| FStar.Pervasives.Native.Mktuple2
#_
#_
(FStar.Pervasives.Native.Some #_ l1)
(FStar.Pervasives.Native.Some #_ l2) ->
FStar.Pervasives.Native.Some (l1 @ l2)
| _ -> FStar.Pervasives.Native.None) } | {
"end_col": 3,
"end_line": 821,
"start_col": 2,
"start_line": 803
} |
Prims.Tot | val grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool))
(f':
(#rrel: _ -> #rel: _ -> sl: slice rrel rel -> pos: U32.t
-> HST.Stack bool
(requires (fun h -> valid p h sl pos))
(ensures
(fun h res h' -> B.modifies B.loc_none h h' /\ res == f (contents p h sl pos))))
)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0) })
: Tot
(r':
greader h0 sout pout_from0 bool {grvalue r' == L.existsb f (contents_list p h0 sl pos pos')}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool)) // should be GTot, but List.find requires Tot
(f' : (
(#rrel: _) ->
(#rel: _) ->
(sl: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack bool
(requires (fun h ->
valid p h sl pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (contents p h sl pos)
))
))
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 bool { grvalue r' == L.existsb f (contents_list p h0 sl pos pos') } )
= GReader (Ghost.hide (L.existsb f (contents_list p h0 sl pos pos'))) (fun _ ->
list_existsb j f f' sl pos pos'
) | val grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool))
(f':
(#rrel: _ -> #rel: _ -> sl: slice rrel rel -> pos: U32.t
-> HST.Stack bool
(requires (fun h -> valid p h sl pos))
(ensures
(fun h res h' -> B.modifies B.loc_none h h' /\ res == f (contents p h sl pos))))
)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0) })
: Tot
(r':
greader h0 sout pout_from0 bool {grvalue r' == L.existsb f (contents_list p h0 sl pos pos')})
let grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool))
(f':
(#rrel: _ -> #rel: _ -> sl: slice rrel rel -> pos: U32.t
-> HST.Stack bool
(requires (fun h -> valid p h sl pos))
(ensures
(fun h res h' -> B.modifies B.loc_none h h' /\ res == f (contents p h sl pos))))
)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0) })
: Tot
(r':
greader h0 sout pout_from0 bool {grvalue r' == L.existsb f (contents_list p h0 sl pos pos')}) = | false | null | false | GReader (Ghost.hide (L.existsb f (contents_list p h0 sl pos pos')))
(fun _ -> list_existsb j f f' sl pos pos') | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"Prims.bool",
"LowParse.Slice.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Low.Base.Spec.valid",
"Prims.l_and",
"LowStar.Monotonic.Buffer.modifies",
"LowStar.Monotonic.Buffer.loc_none",
"Prims.eq2",
"LowParse.Low.Base.Spec.contents",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"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_list",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Slice.loc_slice_from",
"LowParse.Low.Writers.GReader",
"FStar.Ghost.hide",
"FStar.List.Tot.Base.existsb",
"LowParse.Low.Base.Spec.contents_list",
"Prims.unit",
"LowParse.Low.Base.list_existsb",
"LowParse.Low.Writers.greader",
"LowParse.Low.Writers.grvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
)
inline_for_extraction
noextract
let olwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: olwriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None) } )
= OLWriter (Ghost.hide (match olwvalue w1, olwvalue w2 with | Some l1, Some l2 -> Some (l1 `List.Tot.append` l2) | _ -> None)) (fun pout_from ->
let res1 = olwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if (max_uint32 `U32.sub` 1ul) `U32.lte` res1
then
res1
else begin
let res2 = olwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let olwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (olwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (olwriter s h0 sout pout_from0)))
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (if cond then olwvalue (wtrue ()) else olwvalue (wfalse ())) } )
= OLWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then olwrite (wtrue ()) pout_from else olwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let olwriter_of_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (olwriter s h0 sout pout_from0)
= OLWriter (Ghost.hide (Some (lwvalue w))) (fun pout_from -> lwrite w pout_from)
inline_for_extraction
noextract
let wcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
B.loc_disjoint (loc_slice_from_to sin pin_from pin_to) (loc_slice_from sout sout_from0) /\
valid_pos p h0 sin pin_from pin_to
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak_with_length p sin pin_from pin_to sout sout_from
)
inline_for_extraction
noextract
let wjcopy
(#k: _)
(#t: _)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong})
(j: jumper p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(sout_from0: U32.t)
(h0: HS.mem {
valid p h0 sin pin_from /\
B.loc_disjoint (loc_slice_from_to sin pin_from (get_valid_pos p h0 sin pin_from)) (loc_slice_from sout sout_from0)
})
: Tot (w: writer s h0 sout sout_from0 {
wvalue w == contents p h0 sin pin_from
})
= Writer (Ghost.hide (contents p h0 sin pin_from)) (fun sout_from ->
copy_weak p j sin pin_from sout sout_from
)
(* monadic-style bind to read contents from h0 *)
inline_for_extraction
noextract
noeq
type greader
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(t: Type)
= | GReader:
(v: Ghost.erased t) ->
(f: (
unit ->
HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == Ghost.reveal v
)))) ->
greader h0 sout pout_from0 t
let grvalue
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: GTot t
= Ghost.reveal (GReader?.v r)
inline_for_extraction
noextract
let gread
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#t: Type)
(r: greader h0 sout pout_from0 t)
: HST.Stack t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == grvalue r
))
= match r with
| GReader _ f -> f ()
inline_for_extraction
noextract
let swbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (swriter s h0 space_beyond sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : swriter s h0 space_beyond sout pout_from0 { swvalue w' == swvalue (w (grvalue r)) } )
= SWriter (Ghost.hide (swvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
swrite (w v) pout_from
)
inline_for_extraction
noextract
let wbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (writer s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : writer s h0 sout pout_from0 { wvalue w' == wvalue (w (grvalue r)) } )
= Writer (Ghost.hide (wvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
write (w v) pout_from
)
inline_for_extraction
noextract
let owbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (owriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : owriter s h0 sout pout_from0 { owvalue w' == owvalue (w (grvalue r))})
= OWriter (Ghost.hide (owvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
owrite (w v) pout_from
)
inline_for_extraction
noextract
let lwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (lwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Tot (w' : lwriter s h0 sout pout_from0 { lwvalue w' == lwvalue (w (grvalue r)) } )
= LWriter (Ghost.hide (lwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
lwrite (w v) pout_from
)
inline_for_extraction
noextract
let olwbind
(#tr: Type)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(r: greader h0 sout pout_from0 tr)
(w: ((x: tr) -> Pure (olwriter s h0 sout pout_from0) (requires (x == grvalue r)) (ensures (fun _ -> True))))
: Pure (olwriter s h0 sout pout_from0)
(requires True)
(ensures (fun w' -> olwvalue w' == olwvalue (w (grvalue r))))
= OLWriter (Ghost.hide (olwvalue (w (grvalue r)))) (fun pout_from ->
let v = gread r in
olwrite (w v) pout_from
)
inline_for_extraction
noextract
let greader_tot
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(#t: Type)
(x: t)
: Tot (r: greader h0 sout pout_from0 t { grvalue r == x } )
= GReader (Ghost.hide x) (fun _ -> x)
inline_for_extraction
noextract
let graccess
(#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)
(a: accessor g)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k1.parser_kind_subkind == Some ParserStrong /\
k2.parser_kind_subkind == Some ParserStrong /\
valid p1 h0 sin pin /\
cl.clens_cond (contents p1 h0 sin pin) /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p1 h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r: greader h0 sout pout_from0 U32.t { grvalue r == slice_access h0 g sin pin } )
= GReader (Ghost.hide (slice_access h0 g sin pin)) (fun _ ->
a sin pin
)
inline_for_extraction
noextract
let read_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(r: leaf_reader p)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin: U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid p h0 sin pin /\
B.loc_disjoint (loc_slice_from_to sin pin (get_valid_pos p h0 sin pin)) (loc_slice_from sout pout_from0)
})
: Tot (r' : greader h0 sout pout_from0 t { grvalue r' == contents p h0 sin pin } )
= GReader (Ghost.hide (contents p h0 sin pin)) (fun _ ->
r sin pin
)
inline_for_extraction
noextract
let grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool)) // should be GTot, but List.find requires Tot
(f' : (
(#rrel: _) ->
(#rel: _) ->
(sl: slice rrel rel) ->
(pos: U32.t) ->
HST.Stack bool
(requires (fun h ->
valid p h sl pos
))
(ensures (fun h res h' ->
B.modifies B.loc_none h h' /\
res == f (contents p h sl pos)
))
))
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos' : U32.t)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0: HS.mem {
k.parser_kind_subkind == Some ParserStrong /\
valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0)
}) | false | false | LowParse.Low.Writers.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 grlexistsb
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(j: jumper p)
(f: (t -> Tot bool))
(f':
(#rrel: _ -> #rel: _ -> sl: slice rrel rel -> pos: U32.t
-> HST.Stack bool
(requires (fun h -> valid p h sl pos))
(ensures
(fun h res h' -> B.modifies B.loc_none h h' /\ res == f (contents p h sl pos))))
)
(#rrel #rel: _)
(sl: slice rrel rel)
(pos pos': U32.t)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(h0:
HS.mem
{ k.parser_kind_subkind == Some ParserStrong /\ valid_list p h0 sl pos pos' /\
B.loc_disjoint (loc_slice_from_to sl pos pos') (loc_slice_from sout pout_from0) })
: Tot
(r':
greader h0 sout pout_from0 bool {grvalue r' == L.existsb f (contents_list p h0 sl pos pos')}) | [] | LowParse.Low.Writers.grlexistsb | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
j: LowParse.Low.Base.jumper p ->
f: (_: t -> Prims.bool) ->
f':
(sl: LowParse.Slice.slice rrel rel -> pos: FStar.UInt32.t
-> FStar.HyperStack.ST.Stack Prims.bool) ->
sl: LowParse.Slice.slice rrel rel ->
pos: FStar.UInt32.t ->
pos': FStar.UInt32.t ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t ->
h0:
FStar.Monotonic.HyperStack.mem
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
LowParse.Low.Base.Spec.valid_list p h0 sl pos pos' /\
LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from_to sl pos pos')
(LowParse.Slice.loc_slice_from sout pout_from0) }
-> r':
LowParse.Low.Writers.greader h0 sout pout_from0 Prims.bool
{ LowParse.Low.Writers.grvalue r' ==
FStar.List.Tot.Base.existsb f (LowParse.Low.Base.Spec.contents_list p h0 sl pos pos') } | {
"end_col": 3,
"end_line": 1148,
"start_col": 2,
"start_line": 1146
} |
Prims.Tot | val lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 {k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0})
(f: (t1 -> Tot t2))
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0:
U32.t
{ B.loc_disjoint (loc_slice_from sout pout_from0)
(loc_slice_from_to sin pin_from pin_to) /\ valid_list p1 h0 sin pin_from pin_to })
(f':
(
pos:
U32.t
{ U32.v pin_from <= U32.v pos /\ valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to }
-> Tot (y: writer s2 h0 sout pout_from0 {wvalue y == f (contents p1 h0 sin pos)})))
: Tot
(x:
lwriter s2 h0 sout pout_from0
{lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to)}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
) | val lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 {k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0})
(f: (t1 -> Tot t2))
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0:
U32.t
{ B.loc_disjoint (loc_slice_from sout pout_from0)
(loc_slice_from_to sin pin_from pin_to) /\ valid_list p1 h0 sin pin_from pin_to })
(f':
(
pos:
U32.t
{ U32.v pin_from <= U32.v pos /\ valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to }
-> Tot (y: writer s2 h0 sout pout_from0 {wvalue y == f (contents p1 h0 sin pos)})))
: Tot
(x:
lwriter s2 h0 sout pout_from0
{lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to)})
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 {k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0})
(f: (t1 -> Tot t2))
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0:
U32.t
{ B.loc_disjoint (loc_slice_from sout pout_from0)
(loc_slice_from_to sin pin_from pin_to) /\ valid_list p1 h0 sin pin_from pin_to })
(f':
(
pos:
U32.t
{ U32.v pin_from <= U32.v pos /\ valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to }
-> Tot (y: writer s2 h0 sout pout_from0 {wvalue y == f (contents p1 h0 sin pos)})))
: Tot
(x:
lwriter s2 h0 sout pout_from0
{lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to)}) = | false | null | false | LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to)))
(fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map j1 s2 f h sin pin_from pin_to sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1
h0
sin
pin_
(get_valid_pos p1 h sin pin_)
(loc_slice_from sout pout_from0)
h;
write (f' pin_) pout_)) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Low.Base.jumper",
"LowParse.Spec.Base.serializer",
"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.srel",
"LowParse.Bytes.byte",
"LowParse.Slice.slice",
"FStar.UInt32.t",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.srel_of_buffer_srel",
"LowStar.Buffer.trivial_preorder",
"LowStar.Monotonic.Buffer.loc_disjoint",
"LowParse.Slice.loc_slice_from",
"LowParse.Slice.loc_slice_from_to",
"LowParse.Low.Base.Spec.valid_list",
"Prims.op_LessThanOrEqual",
"FStar.UInt32.v",
"LowParse.Low.Base.Spec.valid",
"Prims.op_Addition",
"LowParse.Low.Base.Spec.content_length",
"LowParse.Low.Writers.writer",
"LowParse.Low.Writers.wvalue",
"LowParse.Low.Base.Spec.contents",
"LowParse.Low.Writers.LWriter",
"FStar.Ghost.hide",
"Prims.list",
"FStar.List.Tot.Base.map",
"LowParse.Low.Base.Spec.contents_list",
"LowParse.Low.Base.list_map",
"LowParse.Low.Writers.write",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_pos_frame_strong",
"LowParse.Low.Base.Spec.get_valid_pos",
"FStar.HyperStack.ST.get",
"Prims._assert",
"LowParse.Low.Writers.lwriter",
"LowParse.Low.Writers.lwvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
)) | false | false | LowParse.Low.Writers.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 lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 {k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0})
(f: (t1 -> Tot t2))
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0:
U32.t
{ B.loc_disjoint (loc_slice_from sout pout_from0)
(loc_slice_from_to sin pin_from pin_to) /\ valid_list p1 h0 sin pin_from pin_to })
(f':
(
pos:
U32.t
{ U32.v pin_from <= U32.v pos /\ valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to }
-> Tot (y: writer s2 h0 sout pout_from0 {wvalue y == f (contents p1 h0 sin pos)})))
: Tot
(x:
lwriter s2 h0 sout pout_from0
{lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to)}) | [] | LowParse.Low.Writers.lwriter_list_map | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
j1: LowParse.Low.Base.jumper p1 ->
s2:
LowParse.Spec.Base.serializer p2
{ Mkparser_kind'?.parser_kind_subkind k2 ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_low k2 > 0 } ->
f: (_: t1 -> t2) ->
sin: LowParse.Slice.slice rrel rel ->
pin_from: FStar.UInt32.t ->
pin_to: FStar.UInt32.t ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0:
FStar.UInt32.t
{ LowStar.Monotonic.Buffer.loc_disjoint (LowParse.Slice.loc_slice_from sout pout_from0)
(LowParse.Slice.loc_slice_from_to sin pin_from pin_to) /\
LowParse.Low.Base.Spec.valid_list p1 h0 sin pin_from pin_to } ->
f':
(
pos:
FStar.UInt32.t
{ FStar.UInt32.v pin_from <= FStar.UInt32.v pos /\
LowParse.Low.Base.Spec.valid p1 h0 sin pos /\
FStar.UInt32.v pos + LowParse.Low.Base.Spec.content_length p1 h0 sin pos <=
FStar.UInt32.v pin_to }
-> y:
LowParse.Low.Writers.writer s2 h0 sout pout_from0
{LowParse.Low.Writers.wvalue y == f (LowParse.Low.Base.Spec.contents p1 h0 sin pos)})
-> x:
LowParse.Low.Writers.lwriter s2 h0 sout pout_from0
{ LowParse.Low.Writers.lwvalue x ==
FStar.List.Tot.Base.map f (LowParse.Low.Base.Spec.contents_list p1 h0 sin pin_from pin_to) } | {
"end_col": 3,
"end_line": 497,
"start_col": 2,
"start_line": 483
} |
Prims.Tot | val olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match owvalue w with
| None -> None
| Some x -> Some [x]) }) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == (match owvalue w with None -> None | Some x -> Some [x]) })
= OLWriter (Ghost.hide (match owvalue w with None -> None | Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (requires (Some? (owvalue w))) (ensures (match owvalue w with | None -> False | Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ()
end;
res
) | val olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match owvalue w with
| None -> None
| Some x -> Some [x]) })
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match owvalue w with
| None -> None
| Some x -> Some [x]) }) = | false | null | false | OLWriter
(Ghost.hide (match owvalue w with
| None -> None
| Some x -> Some [x]))
(fun pout_from ->
let res = owrite w pout_from in
if res `U32.lt` (max_uint32 `U32.sub` 1ul)
then
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
else
([@@ inline_let ]let f ()
: Lemma (requires (Some? (owvalue w)))
(ensures
(match owvalue w with
| None -> False
| Some v -> serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (Some?.v (owvalue w)) [];
serialized_list_length_nil s
in
Classical.move_requires f ());
res) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.owriter",
"LowParse.Low.Writers.OLWriter",
"FStar.Ghost.hide",
"Prims.list",
"LowParse.Low.Writers.owvalue",
"FStar.Pervasives.Native.None",
"Prims.Cons",
"Prims.Nil",
"Prims.unit",
"FStar.UInt32.lt",
"FStar.UInt32.sub",
"LowParse.Low.ErrorCode.max_uint32",
"FStar.UInt32.__uint_to_t",
"LowParse.Low.Base.Spec.valid_list_cons",
"LowParse.Low.Base.Spec.valid_list_nil",
"FStar.HyperStack.ST.get",
"Prims.bool",
"FStar.Classical.move_requires",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.l_False",
"Prims.nat",
"LowParse.Low.Base.Spec.serialized_list_length",
"LowParse.Low.Base.Spec.serialized_length",
"Prims.squash",
"FStar.Pervasives.pattern",
"LowParse.Low.Base.Spec.serialized_list_length_nil",
"LowParse.Low.Base.Spec.serialized_list_length_cons",
"FStar.Pervasives.Native.__proj__Some__item__v",
"LowParse.Low.Writers.owrite",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.olwvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0) | false | false | LowParse.Low.Writers.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 olwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(#h0: HS.mem)
(#sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot
(x:
olwriter s h0 sout pout_from0
{ olwvalue x ==
(match owvalue w with
| None -> None
| Some x -> Some [x]) }) | [] | LowParse.Low.Writers.olwriter_singleton | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | w: LowParse.Low.Writers.owriter s h0 sout pout_from0
-> x:
LowParse.Low.Writers.olwriter s h0 sout pout_from0
{ LowParse.Low.Writers.olwvalue x ==
(match LowParse.Low.Writers.owvalue w with
| FStar.Pervasives.Native.None #_ -> FStar.Pervasives.Native.None
| FStar.Pervasives.Native.Some #_ x -> FStar.Pervasives.Native.Some [x]) } | {
"end_col": 3,
"end_line": 789,
"start_col": 2,
"start_line": 772
} |
Prims.Tot | val olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 {olwvalue x == Some []}) | [
{
"abbrev": true,
"full_module": "FStar.List.Tot",
"short_module": "L"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "LowStar.Buffer",
"short_module": "B"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack.ST",
"short_module": "HST"
},
{
"abbrev": true,
"full_module": "FStar.HyperStack",
"short_module": "HS"
},
{
"abbrev": false,
"full_module": "LowParse.Low.Base",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Low",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 { olwvalue x == Some [] })
= OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
) | val olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 {olwvalue x == Some []})
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 {olwvalue x == Some []}) = | false | null | false | OLWriter (Ghost.hide (Some []))
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from) | {
"checked_file": "LowParse.Low.Writers.fst.checked",
"dependencies": [
"prims.fst.checked",
"LowStar.Buffer.fst.checked",
"LowParse.Low.Base.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.List.Tot.fst.checked",
"FStar.HyperStack.ST.fsti.checked",
"FStar.HyperStack.fst.checked",
"FStar.Ghost.fsti.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Low.Writers.fst"
} | [
"total"
] | [
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"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",
"FStar.Monotonic.HyperStack.mem",
"LowParse.Slice.slice",
"LowParse.Slice.srel_of_buffer_srel",
"LowParse.Bytes.byte",
"LowStar.Buffer.trivial_preorder",
"FStar.UInt32.t",
"LowParse.Low.Writers.OLWriter",
"FStar.Ghost.hide",
"Prims.list",
"Prims.Nil",
"Prims.unit",
"LowParse.Low.Base.Spec.valid_list_nil",
"FStar.HyperStack.ST.get",
"LowParse.Low.Writers.olwriter",
"LowParse.Low.Writers.olwvalue"
] | [] | module LowParse.Low.Writers
include LowParse.Low.Base
module HS = FStar.HyperStack
module HST = FStar.HyperStack.ST
module B = LowStar.Buffer
module U32 = FStar.UInt32
module L = FStar.List.Tot
inline_for_extraction
noextract
let fswriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from + serialized_length s x + space_beyond <= U32.v sout.len
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\
valid_content_pos p h' sout pout_from x res
))
inline_for_extraction
noextract
noeq
type swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(space_beyond: nat)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | SWriter:
(v: Ghost.erased t) ->
(w: fswriter s h0 space_beyond sout pout_from0 (Ghost.reveal v)) ->
swriter s h0 space_beyond sout pout_from0
let swvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_swriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#space_beyond0: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: swriter s h0 space_beyond0 sout pout_from0)
(h1: HS.mem)
(space_beyond1: nat)
(pout_from1: U32.t)
: Pure (w' : swriter s h1 space_beyond1 sout pout_from1 { swvalue w' == swvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1 /\ space_beyond0 <= space_beyond1))
(ensures (fun _ -> True))
= SWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let swrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(#space_beyond: nat)
(w: swriter s h0 space_beyond sout pout_from0)
: Tot (fswriter s h0 space_beyond sout pout_from0 (swvalue w))
= match w with | SWriter _ f -> f
inline_for_extraction
noextract
let swriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#space_beyond: nat)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (swriter s h0 space_beyond sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (swriter s h0 space_beyond sout pout_from0)))
: Tot (x: swriter s h0 space_beyond sout pout_from0 { swvalue x == (if cond then swvalue (wtrue ()) else swvalue (wfalse ())) } )
= SWriter (if cond then SWriter?.v (wtrue ()) else SWriter?.v (wfalse ()))
(fun pout_from -> if cond then swrite (wtrue ()) pout_from else swrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let swrite_leaf
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: swriter s h0 0 sout pout_from0 { swvalue y == x } )
= SWriter (Ghost.hide x)
(fun pout_from -> w x sout pout_from)
inline_for_extraction
noextract
let fwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_length s x > U32.v sout.len
else valid_content_pos p h' sout pout_from x res
)))
inline_for_extraction
noextract
noeq
type writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | Writer:
(v: Ghost.erased t) ->
(w: fwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
writer s h0 sout pout_from0
let wvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: GTot t
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : writer s h1 sout pout_from1 { wvalue w' == wvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= Writer w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let write
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (fwriter s h0 sout pout_from0 (wvalue w))
= match w with | Writer _ f -> f
inline_for_extraction
noextract
let writer_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (writer s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (writer s h0 sout pout_from0)))
: Tot (x: writer s h0 sout pout_from0 { wvalue x == (if cond then wvalue (wtrue ()) else wvalue (wfalse ())) } )
= Writer (if cond then Writer?.v (wtrue ()) else Writer?.v (wfalse ()))
(fun pout_from -> if cond then write (wtrue ()) pout_from else write (wfalse ()) pout_from)
inline_for_extraction
noextract
let write_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: writer s h0 sout pout_from0 { wvalue y == x } )
= Writer (Ghost.hide x)
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let flwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: list t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then U32.v pout_from + serialized_list_length s x > U32.v sout.len
else
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == x
)))
inline_for_extraction
noeq
noextract
type lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | LWriter:
(v: Ghost.erased (list t)) ->
(w: flwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
lwriter s h0 sout pout_from0
inline_for_extraction
noextract
let lwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: GTot (list t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_lwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : lwriter s h1 sout pout_from1 { lwvalue w' == lwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= LWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let lwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: lwriter s h0 sout pout_from0)
: Tot (flwriter s h0 sout pout_from0 (lwvalue w))
= match w with | LWriter _ f -> f
inline_for_extraction
noextract
let lwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [] })
= LWriter (Ghost.hide [])
(fun pout_from ->
let h = HST.get () in
valid_list_nil p h sout pout_from;
pout_from
)
inline_for_extraction
noextract
let lwriter_singleton
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == [wvalue w] } )
= LWriter (Ghost.hide [wvalue w])
(fun pout_from ->
let res = write w pout_from in
if res `U32.lt` max_uint32
then begin
let h = HST.get () in
valid_list_nil p h sout res;
valid_list_cons p h sout pout_from res
end else begin
[@inline_let]
let f () : Lemma (ensures (let v = wvalue w in serialized_list_length s [v] == serialized_length s v)) =
serialized_list_length_cons s (wvalue w) [];
serialized_list_length_nil s
in
f ()
end;
res
)
inline_for_extraction
noextract
let lwriter_append
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w1 w2: lwriter s h0 sout pout_from0)
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == lwvalue w1 `List.Tot.append` lwvalue w2 } )
= LWriter (Ghost.hide (lwvalue w1 `List.Tot.append` lwvalue w2)) (fun pout_from ->
let res1 = lwrite w1 pout_from in
Classical.forall_intro_2 (serialized_list_length_append s);
if res1 = max_uint32
then
res1
else begin
let res2 = lwrite w2 res1 in
let h = HST.get () in
valid_list_serialized_list_length s h sout pout_from res1;
if res2 `U32.lt` (max_uint32)
then begin
valid_list_serialized_list_length s h sout res1 res2;
valid_list_append p h sout pout_from res1 res2;
valid_list_serialized_list_length s h sout pout_from res2
end;
res2
end
)
inline_for_extraction
noextract
let lwriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (lwriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (lwriter s h0 sout pout_from0)))
: Tot (x: lwriter s h0 sout pout_from0 { lwvalue x == (if cond then lwvalue (wtrue ()) else lwvalue (wfalse ())) } )
= LWriter (if cond then (wtrue ()).v else (wfalse ()).v)
(fun pout_from -> if cond then lwrite (wtrue ()) pout_from else lwrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let lwriter_list_map
(#k1: parser_kind)
(#t1: Type)
(#p1: parser k1 t1)
(j1: jumper p1)
(#k2: parser_kind)
(#t2: Type)
(#p2: parser k2 t2)
(s2: serializer p2 { k2.parser_kind_subkind == Some ParserStrong /\ k2.parser_kind_low > 0 } )
(f: t1 -> Tot t2)
(#rrel #rel: _)
(sin: slice rrel rel)
(pin_from pin_to: U32.t)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t {
B.loc_disjoint (loc_slice_from sout pout_from0) (loc_slice_from_to sin pin_from pin_to) /\
valid_list p1 h0 sin pin_from pin_to
})
(f' : (
(pos: U32.t {
U32.v pin_from <= U32.v pos /\
valid p1 h0 sin pos /\
U32.v pos + content_length p1 h0 sin pos <= U32.v pin_to
}) ->
Tot (y: writer s2 h0 sout pout_from0 { wvalue y == f (contents p1 h0 sin pos) })
))
: Tot (x: lwriter s2 h0 sout pout_from0 { lwvalue x == List.Tot.map f (contents_list p1 h0 sin pin_from pin_to) } )
= LWriter (Ghost.hide (List.Tot.map f (contents_list p1 h0 sin pin_from pin_to))) (fun pout_from ->
assert (k1.parser_kind_subkind == Some ParserStrong);
let h = HST.get () in
list_map
j1
s2
f
h
sin pin_from pin_to
sout pout_from
(fun pin_ pout_ ->
valid_pos_frame_strong p1 h0 sin pin_ (get_valid_pos p1 h sin pin_) (loc_slice_from sout pout_from0) h;
write (f' pin_) pout_
)
)
(* With options (other failures) *)
inline_for_extraction
noextract
let fowriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option t)
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
live_slice h sout /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_content_pos p h' sout pout_from (Some?.v x) res
)))
inline_for_extraction
noextract
noeq
type owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OWriter:
(v: Ghost.erased (option t)) ->
(w: fowriter s h0 sout pout_from0 (Ghost.reveal v)) ->
owriter s h0 sout pout_from0
let owvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: GTot (option t)
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_owriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : owriter s h1 sout pout_from1 { owvalue w' == owvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let owrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: owriter s h0 sout pout_from0)
: Tot (fowriter s h0 sout pout_from0 (owvalue w))
= match w with | OWriter _ f -> f
inline_for_extraction
noextract
let owriter_ifthenelse
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(cond: bool)
(wtrue: (squash (cond == true) -> Tot (owriter s h0 sout pout_from0)))
(wfalse: (squash (cond == false) -> Tot (owriter s h0 sout pout_from0)))
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == (if cond then owvalue (wtrue ()) else owvalue (wfalse ())) } )
= OWriter (if cond then OWriter?.v (wtrue ()) else OWriter?.v (wfalse ()))
(fun pout_from -> if cond then owrite (wtrue ()) pout_from else owrite (wfalse ()) pout_from)
inline_for_extraction
noextract
let owrite_leaf_cs
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_high == Some k.parser_kind_low /\ k.parser_kind_low < 4294967296 } )
(w: leaf_writer_strong s)
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: t)
: Tot (y: owriter s h0 sout pout_from0 { owvalue y == Some x } )
= OWriter (Ghost.hide (Some x))
(fun pout_from ->
if U32.uint_to_t k.parser_kind_low `U32.gt` (sout.len `U32.sub` pout_from)
then max_uint32
else w x sout pout_from
)
inline_for_extraction
noextract
let owriter_of_writer
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: writer s h0 sout pout_from0)
: Tot (x: owriter s h0 sout pout_from0 { owvalue x == Some (wvalue w) })
= OWriter (Ghost.hide (Some (wvalue w))) (fun pout_from -> write w pout_from)
inline_for_extraction
noextract
let folwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
(x: option (list t))
: Tot Type
= (pout_from: U32.t) ->
HST.Stack U32.t
(requires (fun h ->
live_slice h sout /\
B.modifies (loc_slice_from sout pout_from0) h0 h /\
U32.v pout_from0 <= U32.v pout_from /\
U32.v pout_from <= U32.v sout.len /\
U32.v sout.len < U32.v max_uint32 - 1
))
(ensures (fun h res h' ->
B.modifies (loc_slice_from sout pout_from) h h' /\ (
if res = max_uint32
then (Some? x ==> U32.v pout_from + serialized_list_length s (Some?.v x) > U32.v sout.len)
else if res = max_uint32 `U32.sub` 1ul
then None? x
else
Some? x /\
valid_list p h' sout pout_from res /\
contents_list p h' sout pout_from res == (Some?.v x)
)))
inline_for_extraction
noeq
noextract
type olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Type
= | OLWriter:
(v: Ghost.erased (option (list t))) ->
(w: folwriter s h0 sout pout_from0 (Ghost.reveal v)) ->
olwriter s h0 sout pout_from0
inline_for_extraction
noextract
let olwvalue
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: GTot (option (list t))
= Ghost.reveal w.v
inline_for_extraction
noextract
let weaken_olwriter
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
(h1: HS.mem)
(pout_from1: U32.t)
: Pure (w' : olwriter s h1 sout pout_from1 { olwvalue w' == olwvalue w } )
(requires (B.modifies (loc_slice_from sout pout_from0) h0 h1 /\ U32.v pout_from0 <= U32.v pout_from1))
(ensures (fun _ -> True))
= OLWriter w.v (fun pout_from -> w.w pout_from)
inline_for_extraction
noextract
let olwrite
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(#s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(#h0: HS.mem)
(#sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(#pout_from0: U32.t)
(w: olwriter s h0 sout pout_from0)
: Tot (folwriter s h0 sout pout_from0 (olwvalue w))
= match w with | OLWriter _ f -> f
inline_for_extraction
noextract
let olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0 } )
(h0: HS.mem)
(sout: slice (srel_of_buffer_srel (B.trivial_preorder _)) (srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t) | false | false | LowParse.Low.Writers.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 olwriter_nil
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {k.parser_kind_subkind == Some ParserStrong /\ k.parser_kind_low > 0})
(h0: HS.mem)
(sout:
slice (srel_of_buffer_srel (B.trivial_preorder _))
(srel_of_buffer_srel (B.trivial_preorder _)))
(pout_from0: U32.t)
: Tot (x: olwriter s h0 sout pout_from0 {olwvalue x == Some []}) | [] | LowParse.Low.Writers.olwriter_nil | {
"file_name": "src/lowparse/LowParse.Low.Writers.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
s:
LowParse.Spec.Base.serializer p
{ Mkparser_kind'?.parser_kind_subkind k ==
FStar.Pervasives.Native.Some LowParse.Spec.Base.ParserStrong /\
Mkparser_kind'?.parser_kind_low k > 0 } ->
h0: FStar.Monotonic.HyperStack.mem ->
sout:
LowParse.Slice.slice (LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte
))
(LowParse.Slice.srel_of_buffer_srel (LowStar.Buffer.trivial_preorder LowParse.Bytes.byte)) ->
pout_from0: FStar.UInt32.t
-> x:
LowParse.Low.Writers.olwriter s h0 sout pout_from0
{LowParse.Low.Writers.olwvalue x == FStar.Pervasives.Native.Some []} | {
"end_col": 3,
"end_line": 758,
"start_col": 2,
"start_line": 753
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let fractional (a:Type u#a) = option (a & perm) | let fractional (a: Type u#a) = | false | null | false | option (a & perm) | {
"checked_file": "Steel.PCMFrac.fst.checked",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm"
] | [] | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real | false | true | Steel.PCMFrac.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 fractional : a: Type -> Type | [] | Steel.PCMFrac.fractional | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | a: Type -> Type | {
"end_col": 47,
"end_line": 6,
"start_col": 30,
"start_line": 6
} |
|
Prims.Tot | val composable (#a: _) : symrel (fractional a) | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let composable #a : symrel (fractional a) =
fun (f0 f1:fractional a) ->
match f0, f1 with
| None, _
| _, None -> True
| Some (x0, p0), Some (x1, p1) -> x0==x1 /\ (sum_perm p0 p1).v <=. one | val composable (#a: _) : symrel (fractional a)
let composable #a : symrel (fractional a) = | false | null | false | fun (f0: fractional a) (f1: fractional a) ->
match f0, f1 with
| None, _ | _, None -> True
| Some (x0, p0), Some (x1, p1) -> x0 == x1 /\ (sum_perm p0 p1).v <=. one | {
"checked_file": "Steel.PCMFrac.fst.checked",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
"total"
] | [
"Steel.PCMFrac.fractional",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"Prims.l_True",
"Prims.l_and",
"Prims.eq2",
"Prims.b2t",
"FStar.Real.op_Less_Equals_Dot",
"Steel.FractionalPermission.__proj__MkPerm__item__v",
"Steel.FractionalPermission.sum_perm",
"FStar.Real.one",
"Prims.prop",
"FStar.PCM.symrel"
] | [] | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real
let fractional (a:Type u#a) = option (a & perm) | false | false | Steel.PCMFrac.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 composable (#a: _) : symrel (fractional a) | [] | Steel.PCMFrac.composable | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | FStar.PCM.symrel (Steel.PCMFrac.fractional a) | {
"end_col": 74,
"end_line": 12,
"start_col": 2,
"start_line": 8
} |
Prims.Tot | val compose (#a: _) (f0: fractional a) (f1: fractional a {composable f0 f1}) : fractional a | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let compose #a (f0:fractional a) (f1:fractional a{composable f0 f1}) : fractional a =
match f0, f1 with
| None, f
| f, None -> f
| Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1) | val compose (#a: _) (f0: fractional a) (f1: fractional a {composable f0 f1}) : fractional a
let compose #a (f0: fractional a) (f1: fractional a {composable f0 f1}) : fractional a = | false | null | false | match f0, f1 with
| None, f | f, None -> f
| Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1) | {
"checked_file": "Steel.PCMFrac.fst.checked",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
"total"
] | [
"Steel.PCMFrac.fractional",
"Steel.PCMFrac.composable",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"FStar.Pervasives.Native.Some",
"Steel.FractionalPermission.sum_perm"
] | [] | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real
let fractional (a:Type u#a) = option (a & perm)
let composable #a : symrel (fractional a) =
fun (f0 f1:fractional a) ->
match f0, f1 with
| None, _
| _, None -> True
| Some (x0, p0), Some (x1, p1) -> x0==x1 /\ (sum_perm p0 p1).v <=. one | false | false | Steel.PCMFrac.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 compose (#a: _) (f0: fractional a) (f1: fractional a {composable f0 f1}) : fractional a | [] | Steel.PCMFrac.compose | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | f0: Steel.PCMFrac.fractional a -> f1: Steel.PCMFrac.fractional a {Steel.PCMFrac.composable f0 f1}
-> Steel.PCMFrac.fractional a | {
"end_col": 60,
"end_line": 17,
"start_col": 2,
"start_line": 14
} |
Prims.Tot | val mk_frame_preserving_upd (#a: Type) (v0: Ghost.erased a) (v1: a)
: Tot (frame_preserving_upd pcm_frac (Some (Ghost.reveal v0, full_perm)) (Some (v1, full_perm))) | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let mk_frame_preserving_upd
(#a: Type)
(v0: Ghost.erased a)
(v1: a)
: Tot (frame_preserving_upd pcm_frac (Some (Ghost.reveal v0, full_perm)) (Some (v1, full_perm)))
= fun _ -> Some (v1, full_perm) | val mk_frame_preserving_upd (#a: Type) (v0: Ghost.erased a) (v1: a)
: Tot (frame_preserving_upd pcm_frac (Some (Ghost.reveal v0, full_perm)) (Some (v1, full_perm)))
let mk_frame_preserving_upd (#a: Type) (v0: Ghost.erased a) (v1: a)
: Tot (frame_preserving_upd pcm_frac (Some (Ghost.reveal v0, full_perm)) (Some (v1, full_perm))) = | false | null | false | fun _ -> Some (v1, full_perm) | {
"checked_file": "Steel.PCMFrac.fst.checked",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
"total"
] | [
"FStar.Ghost.erased",
"Steel.PCMFrac.fractional",
"Prims.l_and",
"FStar.PCM.__proj__Mkpcm__item__refine",
"Steel.PCMFrac.pcm_frac",
"FStar.PCM.compatible",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Ghost.reveal",
"Steel.FractionalPermission.full_perm",
"Prims.l_Forall",
"FStar.PCM.composable",
"Prims.l_imp",
"Prims.eq2",
"FStar.PCM.op",
"FStar.PCM.frame_preserving_upd"
] | [] | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real
let fractional (a:Type u#a) = option (a & perm)
let composable #a : symrel (fractional a) =
fun (f0 f1:fractional a) ->
match f0, f1 with
| None, _
| _, None -> True
| Some (x0, p0), Some (x1, p1) -> x0==x1 /\ (sum_perm p0 p1).v <=. one
let compose #a (f0:fractional a) (f1:fractional a{composable f0 f1}) : fractional a =
match f0, f1 with
| None, f
| f, None -> f
| Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
let pcm_frac #a : pcm (fractional a) = {
p = {
composable = composable;
op = compose;
one = None
};
comm = (fun _ _ -> ());
assoc = (fun _ _ _ -> ());
assoc_r = (fun _ _ _ -> ());
is_unit = (fun _ -> ());
refine = (fun _ -> True)
}
let mk_frame_preserving_upd
(#a: Type)
(v0: Ghost.erased a)
(v1: a) | false | false | Steel.PCMFrac.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 mk_frame_preserving_upd (#a: Type) (v0: Ghost.erased a) (v1: a)
: Tot (frame_preserving_upd pcm_frac (Some (Ghost.reveal v0, full_perm)) (Some (v1, full_perm))) | [] | Steel.PCMFrac.mk_frame_preserving_upd | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | v0: FStar.Ghost.erased a -> v1: a
-> FStar.PCM.frame_preserving_upd Steel.PCMFrac.pcm_frac
(FStar.Pervasives.Native.Some (FStar.Ghost.reveal v0, Steel.FractionalPermission.full_perm))
(FStar.Pervasives.Native.Some (v1, Steel.FractionalPermission.full_perm)) | {
"end_col": 31,
"end_line": 37,
"start_col": 2,
"start_line": 37
} |
Prims.Tot | val pcm_frac (#a: _) : pcm (fractional a) | [
{
"abbrev": false,
"full_module": "FStar.Real",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel.FractionalPermission",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.PCM",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "Steel",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let pcm_frac #a : pcm (fractional a) = {
p = {
composable = composable;
op = compose;
one = None
};
comm = (fun _ _ -> ());
assoc = (fun _ _ _ -> ());
assoc_r = (fun _ _ _ -> ());
is_unit = (fun _ -> ());
refine = (fun _ -> True)
} | val pcm_frac (#a: _) : pcm (fractional a)
let pcm_frac #a : pcm (fractional a) = | false | null | false | {
p = { composable = composable; op = compose; one = None };
comm = (fun _ _ -> ());
assoc = (fun _ _ _ -> ());
assoc_r = (fun _ _ _ -> ());
is_unit = (fun _ -> ());
refine = (fun _ -> True)
} | {
"checked_file": "Steel.PCMFrac.fst.checked",
"dependencies": [
"Steel.FractionalPermission.fst.checked",
"prims.fst.checked",
"FStar.Real.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.PCM.fst.checked",
"FStar.Ghost.fsti.checked"
],
"interface_file": false,
"source_file": "Steel.PCMFrac.fst"
} | [
"total"
] | [
"FStar.PCM.Mkpcm",
"Steel.PCMFrac.fractional",
"FStar.PCM.Mkpcm'",
"Steel.PCMFrac.composable",
"Steel.PCMFrac.compose",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.tuple2",
"Steel.FractionalPermission.perm",
"FStar.PCM.__proj__Mkpcm'__item__composable",
"Prims.unit",
"Prims.l_and",
"FStar.PCM.__proj__Mkpcm'__item__op",
"Prims.l_True",
"Prims.prop",
"FStar.PCM.pcm"
] | [] | module Steel.PCMFrac
include FStar.PCM
include Steel.FractionalPermission
open FStar.Real
let fractional (a:Type u#a) = option (a & perm)
let composable #a : symrel (fractional a) =
fun (f0 f1:fractional a) ->
match f0, f1 with
| None, _
| _, None -> True
| Some (x0, p0), Some (x1, p1) -> x0==x1 /\ (sum_perm p0 p1).v <=. one
let compose #a (f0:fractional a) (f1:fractional a{composable f0 f1}) : fractional a =
match f0, f1 with
| None, f
| f, None -> f
| Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1) | false | false | Steel.PCMFrac.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 pcm_frac (#a: _) : pcm (fractional a) | [] | Steel.PCMFrac.pcm_frac | {
"file_name": "lib/steel/Steel.PCMFrac.fst",
"git_rev": "7fbb54e94dd4f48ff7cb867d3bae6889a635541e",
"git_url": "https://github.com/FStarLang/steel.git",
"project_name": "steel"
} | FStar.PCM.pcm (Steel.PCMFrac.fractional a) | {
"end_col": 26,
"end_line": 29,
"start_col": 2,
"start_line": 20
} |
Prims.Tot | val rotl (a: uint64) (b: size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b | val rotl (a: uint64) (b: size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64
let rotl (a: uint64) (b: size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 = | false | null | false | rotate_left a b | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.uint64",
"Lib.IntTypes.size_t",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.IntTypes.uint_v",
"Lib.IntTypes.U32",
"Lib.IntTypes.PUB",
"Lib.IntTypes.rotate_left",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val rotl (a: uint64) (b: size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 | [] | Spec.SHA3.rotl | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
a: Lib.IntTypes.uint64 ->
b: Lib.IntTypes.size_t{0 < Lib.IntTypes.uint_v b /\ Lib.IntTypes.uint_v b < 64}
-> Lib.IntTypes.uint64 | {
"end_col": 17,
"end_line": 26,
"start_col": 2,
"start_line": 26
} |
Prims.Tot | val state_pi_rho_s: i:size_nat{i <= 24} -> Type0 | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_pi_rho_s i = uint64 & state | val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = | false | null | false | uint64 & state | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.uint64",
"Spec.SHA3.state"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_pi_rho_s: i:size_nat{i <= 24} -> Type0 | [] | Spec.SHA3.state_pi_rho_s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | i: Lib.IntTypes.size_nat{i <= 24} -> Type0 | {
"end_col": 37,
"end_line": 58,
"start_col": 23,
"start_line": 58
} |
Prims.Tot | val state_theta_inner_s_inner (x: index) (_D: uint64) (y: index) (s: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D) | val state_theta_inner_s_inner (x: index) (_D: uint64) (y: index) (s: state) : Tot state
let state_theta_inner_s_inner (x: index) (_D: uint64) (y: index) (s: state) : Tot state = | false | null | false | set s x y (get s x y ^. _D) | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.index",
"Lib.IntTypes.uint64",
"Spec.SHA3.state",
"Spec.SHA3.set",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.get"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C | false | true | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_theta_inner_s_inner (x: index) (_D: uint64) (y: index) (s: state) : Tot state | [] | Spec.SHA3.state_theta_inner_s_inner | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | x: Spec.SHA3.index -> _D: Lib.IntTypes.uint64 -> y: Spec.SHA3.index -> s: Spec.SHA3.state
-> Spec.SHA3.state | {
"end_col": 29,
"end_line": 35,
"start_col": 2,
"start_line": 35
} |
Prims.Tot | val state_permute1 (round: size_nat{round < 24}) (s: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota | val state_permute1 (round: size_nat{round < 24}) (s: state) : Tot state
let state_permute1 (round: size_nat{round < 24}) (s: state) : Tot state = | false | null | false | let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.SHA3.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.state_iota",
"Spec.SHA3.state_chi",
"Spec.SHA3.state_pi_rho",
"Spec.SHA3.state_theta"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round]) | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_permute1 (round: size_nat{round < 24}) (s: state) : Tot state | [] | Spec.SHA3.state_permute1 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | round: Lib.IntTypes.size_nat{round < 24} -> s: Spec.SHA3.state -> Spec.SHA3.state | {
"end_col": 8,
"end_line": 87,
"start_col": 71,
"start_line": 82
} |
Prims.Tot | val state_chi_inner1 (s_pi_rho: state) (y: index) (s: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s | val state_chi_inner1 (s_pi_rho: state) (y: index) (s: state) : Tot state
let state_chi_inner1 (s_pi_rho: state) (y: index) (s: state) : Tot state = | false | null | false | repeati 5 (state_chi_inner0 s_pi_rho y) s | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Spec.SHA3.index",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_chi_inner0"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y)) | false | true | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_chi_inner1 (s_pi_rho: state) (y: index) (s: state) : Tot state | [] | Spec.SHA3.state_chi_inner1 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s_pi_rho: Spec.SHA3.state -> y: Spec.SHA3.index -> s: Spec.SHA3.state -> Spec.SHA3.state | {
"end_col": 43,
"end_line": 74,
"start_col": 2,
"start_line": 74
} |
Prims.Tot | val absorb_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block: lbytes rateInBytes)
(s: state)
: Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s | val absorb_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block: lbytes rateInBytes)
(s: state)
: Tot state
let absorb_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block: lbytes rateInBytes)
(s: state)
: Tot state = | false | null | false | let s = loadState rateInBytes block s in
state_permute s | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Lib.ByteSequence.lbytes",
"Spec.SHA3.state",
"Spec.SHA3.state_permute",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.loadState"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes) | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val absorb_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block: lbytes rateInBytes)
(s: state)
: Tot state | [] | Spec.SHA3.absorb_inner | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
rateInBytes: Lib.IntTypes.size_nat{0 < rateInBytes /\ rateInBytes <= 200} ->
block: Lib.ByteSequence.lbytes rateInBytes ->
s: Spec.SHA3.state
-> Spec.SHA3.state | {
"end_col": 17,
"end_line": 145,
"start_col": 13,
"start_line": 142
} |
Prims.Tot | val set (s: state) (x y: index) (v: uint64) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v | val set (s: state) (x y: index) (v: uint64) : Tot state
let set (s: state) (x y: index) (v: uint64) : Tot state = | false | null | false | s.[ x + 5 * y ] <- v | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Spec.SHA3.index",
"Lib.IntTypes.uint64",
"Lib.Sequence.op_String_Assignment",
"Prims.op_Addition",
"FStar.Mul.op_Star"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y] | false | true | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val set (s: state) (x y: index) (v: uint64) : Tot state | [] | Spec.SHA3.set | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Spec.SHA3.state -> x: Spec.SHA3.index -> y: Spec.SHA3.index -> v: Lib.IntTypes.uint64
-> Spec.SHA3.state | {
"end_col": 20,
"end_line": 23,
"start_col": 2,
"start_line": 23
} |
Prims.Tot | val state_chi_inner0 (s_pi_rho: state) (y x: index) (s: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y)) | val state_chi_inner0 (s_pi_rho: state) (y x: index) (s: state) : Tot state
let state_chi_inner0 (s_pi_rho: state) (y x: index) (s: state) : Tot state = | false | null | false | set s
x
y
(get s_pi_rho x y ^. ((lognot (get s_pi_rho ((x + 1) % 5) y)) &. get s_pi_rho ((x + 2) % 5) y)) | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Spec.SHA3.index",
"Spec.SHA3.set",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.get",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.lognot",
"Prims.op_Modulus",
"Prims.op_Addition"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho | false | true | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_chi_inner0 (s_pi_rho: state) (y x: index) (s: state) : Tot state | [] | Spec.SHA3.state_chi_inner0 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s_pi_rho: Spec.SHA3.state -> y: Spec.SHA3.index -> x: Spec.SHA3.index -> s: Spec.SHA3.state
-> Spec.SHA3.state | {
"end_col": 36,
"end_line": 71,
"start_col": 2,
"start_line": 68
} |
Prims.Tot | val state_chi (s_pi_rho: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho | val state_chi (s_pi_rho: state) : Tot state
let state_chi (s_pi_rho: state) : Tot state = | false | null | false | repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_chi_inner1"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s | false | true | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_chi (s_pi_rho: state) : Tot state | [] | Spec.SHA3.state_chi | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s_pi_rho: Spec.SHA3.state -> Spec.SHA3.state | {
"end_col": 48,
"end_line": 77,
"start_col": 2,
"start_line": 77
} |
Prims.Tot | val state_iota (s: state) (round: size_nat{round < 24}) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round]) | val state_iota (s: state) (round: size_nat{round < 24}) : Tot state
let state_iota (s: state) (round: size_nat{round < 24}) : Tot state = | false | null | false | set s 0 0 (get s 0 0 ^. secret keccak_rndc.[ round ]) | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.SHA3.set",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.get",
"Lib.IntTypes.secret",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.int_t",
"Lib.IntTypes.PUB",
"Spec.SHA3.Constants.keccak_rndc"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_iota (s: state) (round: size_nat{round < 24}) : Tot state | [] | Spec.SHA3.state_iota | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Spec.SHA3.state -> round: Lib.IntTypes.size_nat{round < 24} -> Spec.SHA3.state | {
"end_col": 53,
"end_line": 80,
"start_col": 2,
"start_line": 80
} |
Prims.Tot | val state_permute (s: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_permute (s:state) : Tot state =
repeati 24 state_permute1 s | val state_permute (s: state) : Tot state
let state_permute (s: state) : Tot state = | false | null | false | repeati 24 state_permute1 s | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_permute1"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota | false | true | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_permute (s: state) : Tot state | [] | Spec.SHA3.state_permute | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Spec.SHA3.state -> Spec.SHA3.state | {
"end_col": 29,
"end_line": 90,
"start_col": 2,
"start_line": 90
} |
Prims.Tot | val get (s: state) (x y: index) : Tot uint64 | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y] | val get (s: state) (x y: index) : Tot uint64
let get (s: state) (x y: index) : Tot uint64 = | false | null | false | s.[ x + 5 * y ] | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Spec.SHA3.index",
"Lib.Sequence.op_String_Access",
"Lib.IntTypes.uint64",
"Prims.op_Addition",
"FStar.Mul.op_Star"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5} | false | true | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val get (s: state) (x y: index) : Tot uint64 | [] | Spec.SHA3.get | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Spec.SHA3.state -> x: Spec.SHA3.index -> y: Spec.SHA3.index -> Lib.IntTypes.uint64 | {
"end_col": 15,
"end_line": 20,
"start_col": 2,
"start_line": 20
} |
Prims.Tot | val state_pi_rho (s_theta: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho | val state_pi_rho (s_theta: state) : Tot state
let state_pi_rho (s_theta: state) : Tot state = | false | null | false | let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s state_pi_rho_inner (current, s_theta) in
s_pi_rho | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Lib.IntTypes.uint64",
"Spec.SHA3.state_pi_rho_s",
"Lib.LoopCombinators.repeat_gen",
"Spec.SHA3.state_pi_rho_inner",
"FStar.Pervasives.Native.Mktuple2",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.get"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state | false | true | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_pi_rho (s_theta: state) : Tot state | [] | Spec.SHA3.state_pi_rho | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s_theta: Spec.SHA3.state -> Spec.SHA3.state | {
"end_col": 10,
"end_line": 64,
"start_col": 46,
"start_line": 60
} |
Prims.Tot | val absorb
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(delimitedSuffix: byte_t)
: Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s | val absorb
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(delimitedSuffix: byte_t)
: Tot state
let absorb
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(delimitedSuffix: byte_t)
: Tot state = | false | null | false | repeat_blocks rateInBytes
input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes)
s | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.byte_t",
"Lib.Sequence.repeat_blocks",
"Spec.SHA3.absorb_inner",
"Spec.SHA3.absorb_last"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state = | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val absorb
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(delimitedSuffix: byte_t)
: Tot state | [] | Spec.SHA3.absorb | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: Spec.SHA3.state ->
rateInBytes: Lib.IntTypes.size_nat{0 < rateInBytes /\ rateInBytes <= 200} ->
inputByteLen: Prims.nat ->
input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen} ->
delimitedSuffix: Lib.IntTypes.byte_t
-> Spec.SHA3.state | {
"end_col": 45,
"end_line": 157,
"start_col": 2,
"start_line": 155
} |
Prims.Tot | val shake128
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen) | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 shake128
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1344 256 inputByteLen input (byte 0x1F) outputByteLen | val shake128
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen)
let shake128
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen) = | false | null | false | keccak 1344 256 inputByteLen input (byte 0x1F) outputByteLen | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.size_nat",
"Spec.SHA3.keccak",
"Lib.IntTypes.byte",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block
let squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat):
Tot (lbytes outputByteLen) =
let outBlocks = outputByteLen / rateInBytes in
let a (i:nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a
(squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block
val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen)
let keccak rate capacity inputByteLen input delimitedSuffix outputByteLen =
let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen
let shake128
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) = | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val shake128
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen) | [] | Spec.SHA3.shake128 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
inputByteLen: Prims.nat ->
input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen} ->
outputByteLen: Lib.IntTypes.size_nat
-> Lib.ByteSequence.lbytes outputByteLen | {
"end_col": 62,
"end_line": 208,
"start_col": 2,
"start_line": 208
} |
Prims.Tot | val shake256
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen) | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 shake256
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1088 512 inputByteLen input (byte 0x1F) outputByteLen | val shake256
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen)
let shake256
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen) = | false | null | false | keccak 1088 512 inputByteLen input (byte 0x1F) outputByteLen | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.size_nat",
"Spec.SHA3.keccak",
"Lib.IntTypes.byte",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block
let squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat):
Tot (lbytes outputByteLen) =
let outBlocks = outputByteLen / rateInBytes in
let a (i:nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a
(squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block
val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen)
let keccak rate capacity inputByteLen input delimitedSuffix outputByteLen =
let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen
let shake128
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1344 256 inputByteLen input (byte 0x1F) outputByteLen
let shake256
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) = | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val shake256
(inputByteLen: nat)
(input: bytes{length input == inputByteLen})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen) | [] | Spec.SHA3.shake256 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
inputByteLen: Prims.nat ->
input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen} ->
outputByteLen: Lib.IntTypes.size_nat
-> Lib.ByteSequence.lbytes outputByteLen | {
"end_col": 62,
"end_line": 216,
"start_col": 2,
"start_line": 216
} |
Prims.Tot | val squeeze_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
(i: size_nat{i < outputByteLen / rateInBytes})
(s: state)
: Tot (state & lbytes rateInBytes) | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block | val squeeze_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
(i: size_nat{i < outputByteLen / rateInBytes})
(s: state)
: Tot (state & lbytes rateInBytes)
let squeeze_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
(i: size_nat{i < outputByteLen / rateInBytes})
(s: state)
: Tot (state & lbytes rateInBytes) = | false | null | false | let block = storeState rateInBytes s in
let s = state_permute s in
s, block | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Prims.op_Division",
"Spec.SHA3.state",
"FStar.Pervasives.Native.Mktuple2",
"Lib.ByteSequence.lbytes",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.state_permute",
"Lib.IntTypes.U8",
"Spec.SHA3.storeState",
"FStar.Pervasives.Native.tuple2"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes}) | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val squeeze_inner
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
(i: size_nat{i < outputByteLen / rateInBytes})
(s: state)
: Tot (state & lbytes rateInBytes) | [] | Spec.SHA3.squeeze_inner | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
rateInBytes: Lib.IntTypes.size_nat{0 < rateInBytes /\ rateInBytes <= 200} ->
outputByteLen: Lib.IntTypes.size_nat ->
i: Lib.IntTypes.size_nat{i < outputByteLen / rateInBytes} ->
s: Spec.SHA3.state
-> Spec.SHA3.state * Lib.ByteSequence.lbytes rateInBytes | {
"end_col": 10,
"end_line": 168,
"start_col": 36,
"start_line": 164
} |
Prims.Tot | val state_theta (s: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C | val state_theta (s: state) : Tot state
let state_theta (s: state) : Tot state = | false | null | false | let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Spec.SHA3.state_theta1",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.state_theta0",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.b2t",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s | false | true | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_theta (s: state) : Tot state | [] | Spec.SHA3.state_theta | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Spec.SHA3.state -> Spec.SHA3.state | {
"end_col": 19,
"end_line": 47,
"start_col": 39,
"start_line": 44
} |
Prims.Tot | val storeState (rateInBytes: size_nat{rateInBytes <= 200}) (s: state) : Tot (lbytes rateInBytes) | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes | val storeState (rateInBytes: size_nat{rateInBytes <= 200}) (s: state) : Tot (lbytes rateInBytes)
let storeState (rateInBytes: size_nat{rateInBytes <= 200}) (s: state) : Tot (lbytes rateInBytes) = | false | null | false | let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Spec.SHA3.state",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.storeState_inner",
"Prims.l_and",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_imp",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.u8",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j]) | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val storeState (rateInBytes: size_nat{rateInBytes <= 200}) (s: state) : Tot (lbytes rateInBytes) | [] | Spec.SHA3.storeState | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | rateInBytes: Lib.IntTypes.size_nat{rateInBytes <= 200} -> s: Spec.SHA3.state
-> Lib.ByteSequence.lbytes rateInBytes | {
"end_col": 25,
"end_line": 111,
"start_col": 96,
"start_line": 108
} |
Prims.Tot | val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen) | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 keccak rate capacity inputByteLen input delimitedSuffix outputByteLen =
let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen | val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen)
let keccak rate capacity inputByteLen input delimitedSuffix outputByteLen = | false | null | false | let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.eq2",
"Prims.int",
"Prims.op_Modulus",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_Division",
"Prims.op_LessThanOrEqual",
"Prims.op_Addition",
"Prims.nat",
"Lib.ByteSequence.bytes",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Lib.IntTypes.byte_t",
"Spec.SHA3.squeeze",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Spec.SHA3.absorb",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_Forall",
"Prims.l_imp",
"Prims.op_LessThan",
"Lib.Sequence.index",
"Lib.Sequence.create",
"Lib.IntTypes.uint64",
"Lib.IntTypes.u64",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block
let squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat):
Tot (lbytes outputByteLen) =
let outBlocks = outputByteLen / rateInBytes in
let a (i:nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a
(squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block
val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen) | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen) | [] | Spec.SHA3.keccak | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
rate: Lib.IntTypes.size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600} ->
capacity: Lib.IntTypes.size_nat{capacity + rate == 1600} ->
inputByteLen: Prims.nat ->
input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen} ->
delimitedSuffix: Lib.IntTypes.byte_t ->
outputByteLen: Lib.IntTypes.size_nat
-> Lib.ByteSequence.lbytes outputByteLen | {
"end_col": 37,
"end_line": 200,
"start_col": 75,
"start_line": 196
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C | let state_theta0 (s: state) (_C: lseq uint64 5) = | false | null | false | repeati 5 (state_theta_inner_C s) _C | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_theta_inner_C"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4 | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_theta0 : s: Spec.SHA3.state -> _C: Lib.Sequence.lseq Lib.IntTypes.uint64 5
-> Lib.Sequence.lseq Lib.IntTypes.uint64 5 | [] | Spec.SHA3.state_theta0 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Spec.SHA3.state -> _C: Lib.Sequence.lseq Lib.IntTypes.uint64 5
-> Lib.Sequence.lseq Lib.IntTypes.uint64 5 | {
"end_col": 38,
"end_line": 32,
"start_col": 2,
"start_line": 32
} |
|
Prims.Tot | val loadState (rateInBytes: size_nat{rateInBytes <= 200}) (input: lbytes rateInBytes) (s: state)
: Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s | val loadState (rateInBytes: size_nat{rateInBytes <= 200}) (input: lbytes rateInBytes) (s: state)
: Tot state
let loadState (rateInBytes: size_nat{rateInBytes <= 200}) (input: lbytes rateInBytes) (s: state)
: Tot state = | false | null | false | let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Lib.ByteSequence.lbytes",
"Spec.SHA3.state",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.loadState_inner",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.l_and",
"Prims.eq2",
"Lib.Sequence.sub",
"Prims.l_Forall",
"Prims.nat",
"Prims.l_or",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Lib.Sequence.index",
"Lib.Sequence.update_sub",
"Lib.IntTypes.uint_t",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Prims.l_imp",
"Lib.Sequence.create",
"Lib.IntTypes.u8"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes) | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val loadState (rateInBytes: size_nat{rateInBytes <= 200}) (input: lbytes rateInBytes) (s: state)
: Tot state | [] | Spec.SHA3.loadState | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
rateInBytes: Lib.IntTypes.size_nat{rateInBytes <= 200} ->
input: Lib.ByteSequence.lbytes rateInBytes ->
s: Spec.SHA3.state
-> Spec.SHA3.state | {
"end_col": 38,
"end_line": 103,
"start_col": 13,
"start_line": 99
} |
Prims.Tot | val absorb_next (s: state) (rateInBytes: size_nat{rateInBytes > 0 /\ rateInBytes <= 200})
: Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s | val absorb_next (s: state) (rateInBytes: size_nat{rateInBytes > 0 /\ rateInBytes <= 200})
: Tot state
let absorb_next (s: state) (rateInBytes: size_nat{rateInBytes > 0 /\ rateInBytes <= 200})
: Tot state = | false | null | false | let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[ rateInBytes - 1 ] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_GreaterThan",
"Prims.op_LessThanOrEqual",
"Spec.SHA3.state_permute",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Spec.SHA3.loadState",
"Lib.IntTypes.U8",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Prims.op_Subtraction",
"Lib.IntTypes.mk_int",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_LessThan",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.u8",
"FStar.Seq.Base.create",
"Lib.Sequence.create"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val absorb_next (s: state) (rateInBytes: size_nat{rateInBytes > 0 /\ rateInBytes <= 200})
: Tot state | [] | Spec.SHA3.absorb_next | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Spec.SHA3.state -> rateInBytes: Lib.IntTypes.size_nat{rateInBytes > 0 /\ rateInBytes <= 200}
-> Spec.SHA3.state | {
"end_col": 17,
"end_line": 117,
"start_col": 101,
"start_line": 113
} |
Prims.Tot | val sha3_512 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 64 | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 sha3_512 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 64 =
keccak 576 1024 inputByteLen input (byte 0x06) 64 | val sha3_512 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 64
let sha3_512 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 64 = | false | null | false | keccak 576 1024 inputByteLen input (byte 0x06) 64 | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.SHA3.keccak",
"Lib.IntTypes.byte",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block
let squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat):
Tot (lbytes outputByteLen) =
let outBlocks = outputByteLen / rateInBytes in
let a (i:nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a
(squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block
val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen)
let keccak rate capacity inputByteLen input delimitedSuffix outputByteLen =
let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen
let shake128
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1344 256 inputByteLen input (byte 0x1F) outputByteLen
let shake256
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1088 512 inputByteLen input (byte 0x1F) outputByteLen
let sha3_224 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 28 =
keccak 1152 448 inputByteLen input (byte 0x06) 28
let sha3_256 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 32 =
keccak 1088 512 inputByteLen input (byte 0x06) 32
let sha3_384 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 48 =
keccak 832 768 inputByteLen input (byte 0x06) 48 | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_512 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 64 | [] | Spec.SHA3.sha3_512 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | inputByteLen: Prims.nat -> input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen}
-> Lib.ByteSequence.lbytes 64 | {
"end_col": 51,
"end_line": 228,
"start_col": 2,
"start_line": 228
} |
Prims.Tot | val state_theta1 (s: state) (_C: lseq uint64 5) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s | val state_theta1 (s: state) (_C: lseq uint64 5) : Tot state
let state_theta1 (s: state) (_C: lseq uint64 5) : Tot state = | false | null | false | repeati 5 (state_theta_inner_s _C) s | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_theta_inner_s"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_theta1 (s: state) (_C: lseq uint64 5) : Tot state | [] | Spec.SHA3.state_theta1 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | s: Spec.SHA3.state -> _C: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> Spec.SHA3.state | {
"end_col": 38,
"end_line": 42,
"start_col": 2,
"start_line": 42
} |
Prims.Tot | val squeeze
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen) | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat):
Tot (lbytes outputByteLen) =
let outBlocks = outputByteLen / rateInBytes in
let a (i:nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a
(squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block | val squeeze
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen)
let squeeze
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen) = | false | null | false | let outBlocks = outputByteLen / rateInBytes in
let a (i: nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a (squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Spec.SHA3.state",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Lib.Sequence.seq",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Prims.eq2",
"Prims.int",
"Lib.Sequence.length",
"FStar.Mul.op_Star",
"Lib.Sequence.op_At_Bar",
"Lib.Sequence.to_lseq",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Spec.SHA3.storeState",
"Prims.op_Modulus",
"Lib.ByteSequence.lbytes",
"FStar.Pervasives.Native.tuple2",
"Prims.op_Multiply",
"Lib.Sequence.generate_blocks",
"Spec.SHA3.squeeze_inner",
"Prims.nat",
"Prims.op_Division"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block
let squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}) | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val squeeze
(s: state)
(rateInBytes: size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen: size_nat)
: Tot (lbytes outputByteLen) | [] | Spec.SHA3.squeeze | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
s: Spec.SHA3.state ->
rateInBytes: Lib.IntTypes.size_nat{0 < rateInBytes /\ rateInBytes <= 200} ->
outputByteLen: Lib.IntTypes.size_nat
-> Lib.ByteSequence.lbytes outputByteLen | {
"end_col": 27,
"end_line": 184,
"start_col": 30,
"start_line": 174
} |
Prims.Tot | val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes | val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s = | false | null | false | let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[ rem ] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) && (rem = rateInBytes - 1)
then state_permute s
else s
in
absorb_next s rateInBytes | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.byte_t",
"Lib.IntTypes.size_nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThan",
"Prims.op_LessThanOrEqual",
"Lib.ByteSequence.lbytes",
"Spec.SHA3.state",
"Spec.SHA3.absorb_next",
"Lib.Sequence.lseq",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.op_AmpAmp",
"Prims.op_Negation",
"Lib.IntTypes.op_Equals_Dot",
"Lib.IntTypes.U8",
"Lib.IntTypes.op_Amp_Dot",
"Lib.IntTypes.PUB",
"Lib.IntTypes.byte",
"Prims.op_Equality",
"Prims.int",
"Prims.op_Subtraction",
"Spec.SHA3.state_permute",
"Prims.bool",
"Spec.SHA3.loadState",
"Prims.eq2",
"FStar.Seq.Base.seq",
"Lib.Sequence.to_seq",
"FStar.Seq.Base.upd",
"Lib.IntTypes.byte_to_uint8",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"FStar.Seq.Base.index",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.uint_t",
"Lib.Sequence.sub",
"Prims.op_Addition",
"Lib.Sequence.update_sub",
"FStar.Seq.Base.create",
"Lib.IntTypes.mk_int",
"Lib.Sequence.create",
"Lib.IntTypes.u8"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state | [] | Spec.SHA3.absorb_last | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
delimitedSuffix: Lib.IntTypes.byte_t ->
rateInBytes: Lib.IntTypes.size_nat{0 < rateInBytes /\ rateInBytes <= 200} ->
rem: Lib.IntTypes.size_nat{rem < rateInBytes} ->
input: Lib.ByteSequence.lbytes rem ->
s: Spec.SHA3.state
-> Spec.SHA3.state | {
"end_col": 27,
"end_line": 136,
"start_col": 57,
"start_line": 127
} |
Prims.Tot | val sha3_384 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 48 | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 sha3_384 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 48 =
keccak 832 768 inputByteLen input (byte 0x06) 48 | val sha3_384 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 48
let sha3_384 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 48 = | false | null | false | keccak 832 768 inputByteLen input (byte 0x06) 48 | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.SHA3.keccak",
"Lib.IntTypes.byte",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block
let squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat):
Tot (lbytes outputByteLen) =
let outBlocks = outputByteLen / rateInBytes in
let a (i:nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a
(squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block
val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen)
let keccak rate capacity inputByteLen input delimitedSuffix outputByteLen =
let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen
let shake128
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1344 256 inputByteLen input (byte 0x1F) outputByteLen
let shake256
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1088 512 inputByteLen input (byte 0x1F) outputByteLen
let sha3_224 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 28 =
keccak 1152 448 inputByteLen input (byte 0x06) 28
let sha3_256 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 32 =
keccak 1088 512 inputByteLen input (byte 0x06) 32 | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_384 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 48 | [] | Spec.SHA3.sha3_384 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | inputByteLen: Prims.nat -> input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen}
-> Lib.ByteSequence.lbytes 48 | {
"end_col": 50,
"end_line": 225,
"start_col": 2,
"start_line": 225
} |
Prims.Tot | val loadState_inner (block: lbytes 200) (j: size_nat{j < 25}) (s: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8) | val loadState_inner (block: lbytes 200) (j: size_nat{j < 25}) (s: state) : Tot state
let loadState_inner (block: lbytes 200) (j: size_nat{j < 25}) (s: state) : Tot state = | false | null | false | s.[ j ] <- s.[ j ] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8) | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.ByteSequence.lbytes",
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"Spec.SHA3.state",
"Lib.Sequence.op_String_Assignment",
"Lib.IntTypes.uint64",
"Lib.IntTypes.op_Hat_Dot",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.Sequence.op_String_Access",
"Lib.ByteSequence.uint_from_bytes_le",
"Lib.Sequence.sub",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"FStar.Mul.op_Star"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val loadState_inner (block: lbytes 200) (j: size_nat{j < 25}) (s: state) : Tot state | [] | Spec.SHA3.loadState_inner | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | block: Lib.ByteSequence.lbytes 200 -> j: Lib.IntTypes.size_nat{j < 25} -> s: Spec.SHA3.state
-> Spec.SHA3.state | {
"end_col": 65,
"end_line": 93,
"start_col": 2,
"start_line": 93
} |
Prims.Tot | val sha3_224 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 28 | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 sha3_224 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 28 =
keccak 1152 448 inputByteLen input (byte 0x06) 28 | val sha3_224 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 28
let sha3_224 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 28 = | false | null | false | keccak 1152 448 inputByteLen input (byte 0x06) 28 | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.SHA3.keccak",
"Lib.IntTypes.byte",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block
let squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat):
Tot (lbytes outputByteLen) =
let outBlocks = outputByteLen / rateInBytes in
let a (i:nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a
(squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block
val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen)
let keccak rate capacity inputByteLen input delimitedSuffix outputByteLen =
let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen
let shake128
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1344 256 inputByteLen input (byte 0x1F) outputByteLen
let shake256
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1088 512 inputByteLen input (byte 0x1F) outputByteLen | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_224 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 28 | [] | Spec.SHA3.sha3_224 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | inputByteLen: Prims.nat -> input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen}
-> Lib.ByteSequence.lbytes 28 | {
"end_col": 51,
"end_line": 219,
"start_col": 2,
"start_line": 219
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s | let state_pi_rho_inner (i: size_nat{i < 24}) (current, s) : (uint64 & state) = | false | null | false | let r = keccak_rotc.[ i ] in
let _Y = v keccak_piln.[ i ] in
let temp = s.[ _Y ] in
let s = s.[ _Y ] <- rotl current r in
let current = temp in
current, s | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.IntTypes.size_nat",
"Prims.b2t",
"Prims.op_LessThan",
"FStar.Pervasives.Native.tuple2",
"Lib.IntTypes.uint64",
"Lib.Sequence.lseq",
"FStar.Pervasives.Native.Mktuple2",
"Spec.SHA3.state",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Prims.eq2",
"FStar.Seq.Base.index",
"Lib.Sequence.to_seq",
"Prims.l_and",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.upd",
"Spec.SHA3.rotl",
"Lib.Sequence.index",
"Prims.l_Forall",
"Prims.nat",
"Prims.op_LessThanOrEqual",
"Prims.op_Subtraction",
"Prims.pow2",
"Prims.l_imp",
"Prims.op_disEquality",
"Prims.l_or",
"Lib.Sequence.op_String_Assignment",
"Lib.Sequence.op_String_Access",
"Prims.int",
"Lib.IntTypes.range",
"Lib.IntTypes.U32",
"Lib.IntTypes.v",
"Lib.IntTypes.PUB",
"Spec.SHA3.Constants.piln_t",
"Spec.SHA3.Constants.keccak_piln",
"Spec.SHA3.Constants.rotc_t",
"Spec.SHA3.Constants.keccak_rotc"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_pi_rho_inner : i: Lib.IntTypes.size_nat{i < 24} ->
_: (Lib.IntTypes.uint64 * Lib.Sequence.lseq Lib.IntTypes.uint64 25)
-> Lib.IntTypes.uint64 * Spec.SHA3.state | [] | Spec.SHA3.state_pi_rho_inner | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} |
i: Lib.IntTypes.size_nat{i < 24} ->
_: (Lib.IntTypes.uint64 * Lib.Sequence.lseq Lib.IntTypes.uint64 25)
-> Lib.IntTypes.uint64 * Spec.SHA3.state | {
"end_col": 12,
"end_line": 55,
"start_col": 77,
"start_line": 49
} |
|
Prims.Tot | val state_theta_inner_s (_C: lseq uint64 5) (x: index) (s: state) : Tot state | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s | val state_theta_inner_s (_C: lseq uint64 5) (x: index) (s: state) : Tot state
let state_theta_inner_s (_C: lseq uint64 5) (x: index) (s: state) : Tot state = | false | null | false | let _D = _C.[ (x + 4) % 5 ] ^. (rotl _C.[ (x + 1) % 5 ] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Lib.Sequence.lseq",
"Lib.IntTypes.uint64",
"Spec.SHA3.index",
"Spec.SHA3.state",
"Lib.LoopCombinators.repeati",
"Spec.SHA3.state_theta_inner_s_inner",
"Lib.IntTypes.int_t",
"Lib.IntTypes.U64",
"Lib.IntTypes.SEC",
"Lib.IntTypes.op_Hat_Dot",
"Lib.Sequence.op_String_Access",
"Prims.op_Modulus",
"Prims.op_Addition",
"Spec.SHA3.rotl",
"Lib.IntTypes.size"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D) | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val state_theta_inner_s (_C: lseq uint64 5) (x: index) (s: state) : Tot state | [] | Spec.SHA3.state_theta_inner_s | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | _C: Lib.Sequence.lseq Lib.IntTypes.uint64 5 -> x: Spec.SHA3.index -> s: Spec.SHA3.state
-> Spec.SHA3.state | {
"end_col": 46,
"end_line": 39,
"start_col": 76,
"start_line": 37
} |
Prims.Tot | val sha3_256 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 32 | [
{
"abbrev": false,
"full_module": "Spec.SHA3.Constants",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.LoopCombinators",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.ByteSequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.Sequence",
"short_module": null
},
{
"abbrev": false,
"full_module": "Lib.IntTypes",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "Spec",
"short_module": null
},
{
"abbrev": 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 sha3_256 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 32 =
keccak 1088 512 inputByteLen input (byte 0x06) 32 | val sha3_256 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 32
let sha3_256 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 32 = | false | null | false | keccak 1088 512 inputByteLen input (byte 0x06) 32 | {
"checked_file": "Spec.SHA3.fst.checked",
"dependencies": [
"Spec.SHA3.Constants.fst.checked",
"prims.fst.checked",
"Lib.Sequence.fsti.checked",
"Lib.LoopCombinators.fsti.checked",
"Lib.IntTypes.fsti.checked",
"Lib.ByteSequence.fsti.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked"
],
"interface_file": false,
"source_file": "Spec.SHA3.fst"
} | [
"total"
] | [
"Prims.nat",
"Lib.ByteSequence.bytes",
"Prims.eq2",
"Lib.Sequence.length",
"Lib.IntTypes.uint_t",
"Lib.IntTypes.U8",
"Lib.IntTypes.SEC",
"Spec.SHA3.keccak",
"Lib.IntTypes.byte",
"Lib.ByteSequence.lbytes"
] | [] | module Spec.SHA3
open Lib.IntTypes
open Lib.Sequence
open Lib.ByteSequence
open FStar.Mul
open Lib.LoopCombinators
open Spec.SHA3.Constants
#reset-options "--z3rlimit 50 --max_fuel 0 --max_ifuel 0"
unfold
type state = lseq uint64 25
unfold
type index = n:size_nat{n < 5}
let get (s:state) (x:index) (y:index) : Tot uint64 =
s.[x + 5 * y]
let set (s:state) (x:index) (y:index) (v:uint64) : Tot state =
s.[x + 5 * y] <- v
let rotl (a:uint64) (b:size_t{0 < uint_v b /\ uint_v b < 64}) : Tot uint64 =
rotate_left a b
let state_theta_inner_C (s:state) (i:size_nat{i < 5}) (_C:lseq uint64 5) : Tot (lseq uint64 5) =
_C.[i] <- get s i 0 ^. get s i 1 ^. get s i 2 ^. get s i 3 ^. get s i 4
let state_theta0 (s:state) (_C:lseq uint64 5) =
repeati 5 (state_theta_inner_C s) _C
let state_theta_inner_s_inner (x:index) (_D:uint64) (y:index) (s:state) : Tot state =
set s x y (get s x y ^. _D)
let state_theta_inner_s (_C:lseq uint64 5) (x:index) (s:state) : Tot state =
let _D = _C.[(x + 4) % 5] ^. (rotl _C.[(x + 1) % 5] (size 1)) in
repeati 5 (state_theta_inner_s_inner x _D) s
let state_theta1 (s:state) (_C:lseq uint64 5) : Tot state =
repeati 5 (state_theta_inner_s _C) s
let state_theta (s:state) : Tot state =
let _C = create 5 (u64 0) in
let _C = state_theta0 s _C in
state_theta1 s _C
let state_pi_rho_inner (i:size_nat{i < 24}) (current, s) : (uint64 & state) =
let r = keccak_rotc.[i] in
let _Y = v keccak_piln.[i] in
let temp = s.[_Y] in
let s = s.[_Y] <- rotl current r in
let current = temp in
current, s
val state_pi_rho_s: i:size_nat{i <= 24} -> Type0
let state_pi_rho_s i = uint64 & state
let state_pi_rho (s_theta:state) : Tot state =
let current = get s_theta 1 0 in
let _, s_pi_rho = repeat_gen 24 state_pi_rho_s
state_pi_rho_inner (current, s_theta) in
s_pi_rho
let state_chi_inner0 (s_pi_rho:state) (y:index) (x:index) (s:state) : Tot state =
set s x y
(get s_pi_rho x y ^.
((lognot (get s_pi_rho ((x + 1) % 5) y)) &.
get s_pi_rho ((x + 2) % 5) y))
let state_chi_inner1 (s_pi_rho:state) (y:index) (s:state) : Tot state =
repeati 5 (state_chi_inner0 s_pi_rho y) s
let state_chi (s_pi_rho:state) : Tot state =
repeati 5 (state_chi_inner1 s_pi_rho) s_pi_rho
let state_iota (s:state) (round:size_nat{round < 24}) : Tot state =
set s 0 0 (get s 0 0 ^. secret keccak_rndc.[round])
let state_permute1 (round:size_nat{round < 24}) (s:state) : Tot state =
let s_theta = state_theta s in
let s_pi_rho = state_pi_rho s_theta in
let s_chi = state_chi s_pi_rho in
let s_iota = state_iota s_chi round in
s_iota
let state_permute (s:state) : Tot state =
repeati 24 state_permute1 s
let loadState_inner (block:lbytes 200) (j:size_nat{j < 25}) (s:state) : Tot state =
s.[j] <- s.[j] ^. uint_from_bytes_le #U64 (sub block (j * 8) 8)
let loadState
(rateInBytes:size_nat{rateInBytes <= 200})
(input:lbytes rateInBytes)
(s:state) :
Tot state =
let block = create 200 (u8 0) in
let block = update_sub block 0 rateInBytes input in
repeati 25 (loadState_inner block) s
let storeState_inner (s:state) (j:size_nat{j < 25}) (block:lbytes 200) : Tot (lbytes 200) =
update_sub block (j * 8) 8 (uint_to_bytes_le #U64 s.[j])
let storeState (rateInBytes:size_nat{rateInBytes <= 200}) (s:state) : Tot (lbytes rateInBytes) =
let block = create 200 (u8 0) in
let block = repeati 25 (storeState_inner s) block in
sub block 0 rateInBytes
let absorb_next (s:state) (rateInBytes:size_nat{rateInBytes > 0 /\ rateInBytes <= 200}) : Tot state =
let nextBlock = create rateInBytes (u8 0) in
let nextBlock = nextBlock.[rateInBytes - 1] <- u8 0x80 in
let s = loadState rateInBytes nextBlock s in
state_permute s
val absorb_last:
delimitedSuffix:byte_t
-> rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200}
-> rem:size_nat{rem < rateInBytes}
-> input:lbytes rem
-> s:state ->
Tot state
let absorb_last delimitedSuffix rateInBytes rem input s =
let lastBlock = create rateInBytes (u8 0) in
let lastBlock = update_sub lastBlock 0 rem input in
let lastBlock = lastBlock.[rem] <- byte_to_uint8 delimitedSuffix in
let s = loadState rateInBytes lastBlock s in
let s =
if not ((delimitedSuffix &. byte 0x80) =. byte 0) &&
(rem = rateInBytes - 1)
then state_permute s else s in
absorb_next s rateInBytes
let absorb_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(block:lbytes rateInBytes)
(s:state) :
Tot state =
let s = loadState rateInBytes block s in
state_permute s
let absorb
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(delimitedSuffix:byte_t) :
Tot state =
repeat_blocks rateInBytes input
(absorb_inner rateInBytes)
(absorb_last delimitedSuffix rateInBytes) s
let squeeze_inner
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat)
(i:size_nat{i < outputByteLen / rateInBytes})
(s:state) :
Tot (state & lbytes rateInBytes) =
let block = storeState rateInBytes s in
let s = state_permute s in
s, block
let squeeze
(s:state)
(rateInBytes:size_nat{0 < rateInBytes /\ rateInBytes <= 200})
(outputByteLen:size_nat):
Tot (lbytes outputByteLen) =
let outBlocks = outputByteLen / rateInBytes in
let a (i:nat{i <= outBlocks}) = state in
let s, output =
generate_blocks rateInBytes outBlocks outBlocks a
(squeeze_inner rateInBytes outputByteLen) s
in
let remOut = outputByteLen % rateInBytes in
let block = storeState remOut s in
(to_lseq output) @| block
val keccak:
rate:size_nat{rate % 8 == 0 /\ rate / 8 > 0 /\ rate <= 1600}
-> capacity:size_nat{capacity + rate == 1600}
-> inputByteLen:nat
-> input:bytes{length input == inputByteLen}
-> delimitedSuffix:byte_t
-> outputByteLen:size_nat ->
Tot (lbytes outputByteLen)
let keccak rate capacity inputByteLen input delimitedSuffix outputByteLen =
let rateInBytes = rate / 8 in
let s = create 25 (u64 0) in
let s = absorb s rateInBytes inputByteLen input delimitedSuffix in
squeeze s rateInBytes outputByteLen
let shake128
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1344 256 inputByteLen input (byte 0x1F) outputByteLen
let shake256
(inputByteLen:nat)
(input:bytes{length input == inputByteLen})
(outputByteLen:size_nat) :
Tot (lbytes outputByteLen) =
keccak 1088 512 inputByteLen input (byte 0x1F) outputByteLen
let sha3_224 (inputByteLen:nat) (input:bytes{length input == inputByteLen}) : lbytes 28 =
keccak 1152 448 inputByteLen input (byte 0x06) 28 | false | false | Spec.SHA3.fst | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 0,
"max_ifuel": 0,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": false,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 50,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val sha3_256 (inputByteLen: nat) (input: bytes{length input == inputByteLen}) : lbytes 32 | [] | Spec.SHA3.sha3_256 | {
"file_name": "specs/Spec.SHA3.fst",
"git_rev": "12c5e9539c7e3c366c26409d3b86493548c4483e",
"git_url": "https://github.com/hacl-star/hacl-star.git",
"project_name": "hacl-star"
} | inputByteLen: Prims.nat -> input: Lib.ByteSequence.bytes{Lib.Sequence.length input == inputByteLen}
-> Lib.ByteSequence.lbytes 32 | {
"end_col": 51,
"end_line": 222,
"start_col": 2,
"start_line": 222
} |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.