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 parse_bounded_vldata'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p) | val parse_bounded_vldata'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
let parse_bounded_vldata'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t) = | false | null | false | parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p) | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.strengthen",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.VLData.parse_vldata_gen",
"LowParse.Spec.BoundedInt.in_bounds",
"Prims.unit",
"LowParse.Spec.VLData.parse_bounded_vldata_correct"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t) | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_bounded_vldata'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t) | [] | LowParse.Spec.VLData.parse_bounded_vldata' | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
p: LowParse.Spec.Base.parser k t
-> LowParse.Spec.Base.parser (LowParse.Spec.VLData.parse_bounded_vldata_strong_kind min max l k) t | {
"end_col": 102,
"end_line": 323,
"start_col": 2,
"start_line": 322
} |
FStar.Pervasives.Lemma | val serialize_bounded_vldata_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {serialize_bounded_vldata_precond min max k})
(x: t)
: Lemma
(let Some (_, consumed) = parse p (serialize s x) in
let y =
serialize_bounded_vldata_strong_aux min
max
(log256' max)
s
(x <: parse_bounded_vldata_strong_t min max s)
in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 serialize_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: Lemma
( let Some (_, consumed) = parse p (serialize s x) in
let y = serialize_bounded_vldata_strong_aux min max (log256' max) s (x <: parse_bounded_vldata_strong_t min max s) in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y))
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_strong_correct min max (log256' max) s x;
() | val serialize_bounded_vldata_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {serialize_bounded_vldata_precond min max k})
(x: t)
: Lemma
(let Some (_, consumed) = parse p (serialize s x) in
let y =
serialize_bounded_vldata_strong_aux min
max
(log256' max)
s
(x <: parse_bounded_vldata_strong_t min max s)
in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y))
let serialize_bounded_vldata_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {serialize_bounded_vldata_precond min max k})
(x: t)
: Lemma
(let Some (_, consumed) = parse p (serialize s x) in
let y =
serialize_bounded_vldata_strong_aux min
max
(log256' max)
s
(x <: parse_bounded_vldata_strong_t min max s)
in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y)) = | false | null | true | let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_strong_correct min max (log256' max) s x;
() | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.serialize_bounded_vldata_precond",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.serialize",
"Prims.unit",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_correct",
"LowParse.Spec.BoundedInt.log256'",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"Prims.l_True",
"Prims.squash",
"Prims.eq2",
"LowParse.Spec.VLData.parse_bounded_vldata",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Bytes.bytes",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_aux",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b
let serialize_vldata_gen_correct
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) (Seq.append b1 b2) in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == sz + Seq.length b2
)))) =
seq_slice_append_l b1 b2;
seq_slice_append_r b1 b2;
serialize_vldata_gen_correct_aux sz f p (Seq.append b1 b2) b1 b2
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted == Some (input, Seq.length formatted))
= let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let (len: bounded_integer sz) = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let (Some (len', consumed_len')) = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let (Some (_, consumed_p)) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p
slen
sp
;
()
let serialize_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s))
= Classical.forall_intro (serialize_bounded_vldata_strong_correct min max l s);
serialize_bounded_vldata_strong_aux min max l s
let serialize_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong min max s))
= serialize_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_precond
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(k: parser_kind)
: GTot bool
= match k.parser_kind_high with
| None -> false
| Some max' -> min <= k.parser_kind_low && max' <= max
let serialize_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: Lemma
( let Some (_, consumed) = parse p (serialize s x) in
let y = serialize_bounded_vldata_strong_aux min max (log256' max) s (x <: parse_bounded_vldata_strong_t min max s) in | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_bounded_vldata_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p {serialize_bounded_vldata_precond min max k})
(x: t)
: Lemma
(let Some (_, consumed) = parse p (serialize s x) in
let y =
serialize_bounded_vldata_strong_aux min
max
(log256' max)
s
(x <: parse_bounded_vldata_strong_t min max s)
in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y)) | [] | LowParse.Spec.VLData.serialize_bounded_vldata_correct | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
s:
LowParse.Spec.Base.serializer p
{LowParse.Spec.VLData.serialize_bounded_vldata_precond min max k} ->
x: t
-> FStar.Pervasives.Lemma
(ensures
(let _ = LowParse.Spec.Base.parse p (LowParse.Spec.Base.serialize s x) in
(let FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ _ _) = _ in
let y =
LowParse.Spec.VLData.serialize_bounded_vldata_strong_aux min
max
(LowParse.Spec.BoundedInt.log256' max)
s
x
in
LowParse.Spec.Base.parse (LowParse.Spec.VLData.parse_bounded_vldata min max p) y ==
FStar.Pervasives.Native.Some (x, FStar.Seq.Base.length y))
<:
Type0)) | {
"end_col": 4,
"end_line": 655,
"start_col": 1,
"start_line": 653
} |
Prims.Tot | val serialize_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 serialize_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s))
= Classical.forall_intro (serialize_bounded_vldata_strong_correct min max l s);
serialize_bounded_vldata_strong_aux min max l s | val serialize_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s))
let serialize_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s)) = | false | null | false | Classical.forall_intro (serialize_bounded_vldata_strong_correct min max l s);
serialize_bounded_vldata_strong_aux min max l s | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_aux",
"Prims.unit",
"FStar.Classical.forall_intro",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.VLData.parse_bounded_vldata_strong'",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_correct",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b
let serialize_vldata_gen_correct
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) (Seq.append b1 b2) in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == sz + Seq.length b2
)))) =
seq_slice_append_l b1 b2;
seq_slice_append_r b1 b2;
serialize_vldata_gen_correct_aux sz f p (Seq.append b1 b2) b1 b2
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted == Some (input, Seq.length formatted))
= let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let (len: bounded_integer sz) = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let (Some (len', consumed_len')) = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let (Some (_, consumed_p)) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p
slen
sp
;
()
let serialize_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p) | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s)) | [] | LowParse.Spec.VLData.serialize_bounded_vldata_strong' | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s: LowParse.Spec.Base.serializer p
-> LowParse.Spec.Base.serializer (LowParse.Spec.VLData.parse_bounded_vldata_strong' min max l s) | {
"end_col": 49,
"end_line": 620,
"start_col": 2,
"start_line": 619
} |
Prims.Tot | val parse_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot
(parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s)
) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
) | val parse_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot
(parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s)
)
let parse_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot
(parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s)
) = | false | null | false | (coerce_parser (parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p)
(parse_bounded_vldata_strong_pred min max s)
(parse_bounded_vldata_strong_correct min max l s))) | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.Base.coerce_parser",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"LowParse.Spec.Combinators.parse_strengthen",
"LowParse.Spec.VLData.parse_bounded_vldata'",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_correct"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s)) | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_bounded_vldata_strong'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot
(parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s)
) | [] | LowParse.Spec.VLData.parse_bounded_vldata_strong' | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s: LowParse.Spec.Base.serializer p
-> LowParse.Spec.Base.parser (LowParse.Spec.VLData.parse_bounded_vldata_strong_kind min max l k)
(LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s) | {
"end_col": 3,
"end_line": 460,
"start_col": 2,
"start_line": 456
} |
FStar.Pervasives.Lemma | val serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma (requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let sy = serialize s y in
let y:parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy
))
= serialize_bounded_vldata_strong_upd min max s x y | val serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma (requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let sy = serialize s y in
let y:parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy))
let serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma (requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let sy = serialize s y in
let y:parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy)) = | false | null | true | serialize_bounded_vldata_strong_upd min max s x y | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd",
"Prims.unit",
"Prims.eq2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"Prims.squash",
"Prims.int",
"Prims.op_Addition",
"FStar.Seq.Base.seq",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong",
"LowParse.Spec.Base.seq_upd_bw_seq",
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Bytes.bytes",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b
let serialize_vldata_gen_correct
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) (Seq.append b1 b2) in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == sz + Seq.length b2
)))) =
seq_slice_append_l b1 b2;
seq_slice_append_r b1 b2;
serialize_vldata_gen_correct_aux sz f p (Seq.append b1 b2) b1 b2
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted == Some (input, Seq.length formatted))
= let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let (len: bounded_integer sz) = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let (Some (len', consumed_len')) = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let (Some (_, consumed_p)) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p
slen
sp
;
()
let serialize_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s))
= Classical.forall_intro (serialize_bounded_vldata_strong_correct min max l s);
serialize_bounded_vldata_strong_aux min max l s
let serialize_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong min max s))
= serialize_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_precond
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(k: parser_kind)
: GTot bool
= match k.parser_kind_high with
| None -> false
| Some max' -> min <= k.parser_kind_low && max' <= max
let serialize_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: Lemma
( let Some (_, consumed) = parse p (serialize s x) in
let y = serialize_bounded_vldata_strong_aux min max (log256' max) s (x <: parse_bounded_vldata_strong_t min max s) in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y))
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_strong_correct min max (log256' max) s x;
()
let serialize_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: GTot (y: bytes { parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y) } )
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_correct min max s x;
serialize_bounded_vldata_strong_aux min max (log256' max) s x
let serialize_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
: Tot (serializer (parse_bounded_vldata min max p))
= serialize_bounded_vldata' min max s
let serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy
))
= let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let sy = serialize s y in
let sy' = serialize (serialize_bounded_vldata_strong min max s) y in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
assert (lm + Seq.length sy == Seq.length sx');
seq_upd_seq_right sx' sy;
Seq.lemma_split sx' lm;
Seq.lemma_split sy' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
Seq.lemma_append_inj (Seq.slice sy' 0 lm) (Seq.slice sy' lm (Seq.length sy')) sz sy;
assert (sy' `Seq.equal` seq_upd_seq sx' lm sy)
let serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma (requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let sy = serialize s y in
let y:parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy)) | [] | LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd_bw | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
s: LowParse.Spec.Base.serializer p ->
x: LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s ->
y: t
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s y) ==
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x))
(ensures
(let sy = LowParse.Spec.Base.serialize s y in
let y = y in
let sx =
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
x
in
let lm = LowParse.Spec.BoundedInt.log256' max in
lm + FStar.Seq.Base.length sy == FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
y ==
LowParse.Spec.Base.seq_upd_bw_seq sx 0 sy)) | {
"end_col": 51,
"end_line": 733,
"start_col": 2,
"start_line": 733
} |
FStar.Pervasives.Lemma | val parse_bounded_vldata_elim_forall
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma (requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures
(let Some (x, consumed) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
))) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed | val parse_bounded_vldata_elim_forall
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma (requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures
(let Some (x, consumed) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
)))
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma (requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures
(let Some (x, consumed) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
))) = | false | null | true | let Some (x, consumed) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.VLData.parse_bounded_vldata_elim",
"Prims.unit",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Spec.VLData.parse_bounded_vldata'",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.squash",
"LowParse.Spec.BoundedInt.bounded_integer",
"Prims.eq2",
"LowParse.Spec.BoundedInt.in_bounds",
"FStar.UInt32.v",
"Prims.op_Subtraction",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.op_Addition",
"Prims.logical",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.BoundedInt.integer_size",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_bounded_vldata_elim_forall
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma (requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures
(let Some (x, consumed) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
))) | [] | LowParse.Spec.VLData.parse_bounded_vldata_elim_forall | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
p: LowParse.Spec.Base.parser k t ->
xbytes: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
Some? (LowParse.Spec.Base.parse (LowParse.Spec.VLData.parse_bounded_vldata' min max l p)
xbytes))
(ensures
(let _ =
LowParse.Spec.Base.parse (LowParse.Spec.VLData.parse_bounded_vldata' min max l p) xbytes
in
(let FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed) =
_
in
let sz = l in
let plen =
LowParse.Spec.Base.parse (LowParse.Spec.BoundedInt.parse_bounded_integer sz) xbytes
in
Some? plen /\
(let _ = plen in
(let
FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ len consumed_len) =
_
in
consumed_len == sz /\ LowParse.Spec.BoundedInt.in_bounds min max len /\
FStar.UInt32.v len <= FStar.Seq.Base.length xbytes - sz /\
(let input' = FStar.Seq.Base.slice xbytes sz (sz + FStar.UInt32.v len) in
let pp = LowParse.Spec.Base.parse p input' in
Some? pp /\
(let _ = pp in
(let
FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ x' consumed_p) =
_
in
x' == x /\ consumed_p == FStar.UInt32.v len /\
consumed == sz + FStar.UInt32.v len)
<:
Prims.logical)))
<:
Prims.logical))
<:
Type0)) | {
"end_col": 57,
"end_line": 392,
"start_col": 1,
"start_line": 391
} |
FStar.Pervasives.Lemma | val parse_bounded_vldata_elim
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma (requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures
(let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
))) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed | val parse_bounded_vldata_elim
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma (requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures
(let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
)))
let parse_bounded_vldata_elim
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma (requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures
(let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
))) = | false | null | true | parse_bounded_vldata_elim' min max l p xbytes x consumed | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.VLData.parse_bounded_vldata_elim'",
"Prims.unit",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Spec.VLData.parse_bounded_vldata'",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Prims.squash",
"FStar.Pervasives.Native.uu___is_Some",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.BoundedInt.in_bounds",
"FStar.UInt32.v",
"Prims.op_Subtraction",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.op_Addition",
"Prims.logical",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.BoundedInt.integer_size",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_bounded_vldata_elim
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma (requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures
(let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
))) | [] | LowParse.Spec.VLData.parse_bounded_vldata_elim | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
p: LowParse.Spec.Base.parser k t ->
xbytes: LowParse.Bytes.bytes ->
x: t ->
consumed: LowParse.Spec.Base.consumed_length xbytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.Base.parse (LowParse.Spec.VLData.parse_bounded_vldata' min max l p) xbytes ==
FStar.Pervasives.Native.Some (x, consumed))
(ensures
(let sz = l in
let plen =
LowParse.Spec.Base.parse (LowParse.Spec.BoundedInt.parse_bounded_integer sz) xbytes
in
Some? plen /\
(let _ = plen in
(let
FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ len consumed_len) =
_
in
consumed_len == sz /\ LowParse.Spec.BoundedInt.in_bounds min max len /\
FStar.UInt32.v len <= FStar.Seq.Base.length xbytes - sz /\
(let input' = FStar.Seq.Base.slice xbytes sz (sz + FStar.UInt32.v len) in
let pp = LowParse.Spec.Base.parse p input' in
Some? pp /\
(let _ = pp in
(let
FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ x' consumed_p) =
_
in
x' == x /\ consumed_p == FStar.UInt32.v len /\
consumed == sz + FStar.UInt32.v len)
<:
Prims.logical)))
<:
Prims.logical))) | {
"end_col": 58,
"end_line": 362,
"start_col": 2,
"start_line": 362
} |
Prims.Tot | val serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
) | val serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s)) = | false | null | false | (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl) | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"total"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"FStar.Seq.Base.append",
"LowParse.Bytes.byte",
"Prims.unit",
"LowParse.Spec.Combinators.seq_slice_append_r",
"LowParse.Spec.Combinators.seq_slice_append_l",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.BoundedInt.parse_bounded_integer_kind",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.BoundedInt.serialize_bounded_integer",
"FStar.UInt32.t",
"FStar.UInt32.uint_to_t",
"Prims._assert",
"FStar.Seq.Base.length",
"LowParse.Spec.Base.bare_serializer"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p) | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s)) | [] | LowParse.Spec.VLData.serialize_bounded_vldata_strong_aux | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s: LowParse.Spec.Base.serializer p
-> LowParse.Spec.Base.bare_serializer (LowParse.Spec.VLData.parse_bounded_vldata_strong_t min
max
s) | {
"end_col": 3,
"end_line": 491,
"start_col": 2,
"start_line": 481
} |
FStar.Pervasives.Lemma | val serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires
(Seq.length b1 == sz /\
(let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\
(let Some (len, _) = vlen in
f len == true /\ Seq.length b2 == U32.v len /\
(let vv = parse p b2 in
Some? vv /\
(let Some (_, consumed) = vv in
consumed == Seq.length b2 /\ Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2))))))
(ensures
(let vv = parse p b2 in
Some? vv /\
(let Some (v, consumed) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\
(let Some (v', consumed') = vv' in
v == v' /\ consumed == Seq.length b2 /\ consumed' == Seq.length b)))) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b | val serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires
(Seq.length b1 == sz /\
(let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\
(let Some (len, _) = vlen in
f len == true /\ Seq.length b2 == U32.v len /\
(let vv = parse p b2 in
Some? vv /\
(let Some (_, consumed) = vv in
consumed == Seq.length b2 /\ Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2))))))
(ensures
(let vv = parse p b2 in
Some? vv /\
(let Some (v, consumed) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\
(let Some (v', consumed') = vv' in
v == v' /\ consumed == Seq.length b2 /\ consumed' == Seq.length b))))
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires
(Seq.length b1 == sz /\
(let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\
(let Some (len, _) = vlen in
f len == true /\ Seq.length b2 == U32.v len /\
(let vv = parse p b2 in
Some? vv /\
(let Some (_, consumed) = vv in
consumed == Seq.length b2 /\ Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2))))))
(ensures
(let vv = parse p b2 in
Some? vv /\
(let Some (v, consumed) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\
(let Some (v', consumed') = vv' in
v == v' /\ consumed == Seq.length b2 /\ consumed' == Seq.length b)))) = | false | null | true | let Some (len, consumed1) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.BoundedInt.bounded_integer",
"Prims.bool",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.VLData.parse_vldata_gen_eq",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Bytes.byte",
"FStar.Seq.Base.slice",
"Prims.op_Addition",
"FStar.UInt32.v",
"Prims.int",
"FStar.Seq.Base.length",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Spec.Base.injective_postcond",
"LowParse.Spec.Base.no_lookahead_on",
"Prims.nat",
"Prims.l_or",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.l_and",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.BoundedInt.parse_bounded_integer_kind",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.logical",
"Prims.squash",
"LowParse.Spec.VLData.parse_vldata_gen",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\ | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires
(Seq.length b1 == sz /\
(let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\
(let Some (len, _) = vlen in
f len == true /\ Seq.length b2 == U32.v len /\
(let vv = parse p b2 in
Some? vv /\
(let Some (_, consumed) = vv in
consumed == Seq.length b2 /\ Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2))))))
(ensures
(let vv = parse p b2 in
Some? vv /\
(let Some (v, consumed) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\
(let Some (v', consumed') = vv' in
v == v' /\ consumed == Seq.length b2 /\ consumed' == Seq.length b)))) | [] | LowParse.Spec.VLData.serialize_vldata_gen_correct_aux | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
sz: LowParse.Spec.BoundedInt.integer_size ->
f: (_: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) ->
p: LowParse.Spec.Base.parser k t ->
b: LowParse.Bytes.bytes ->
b1: LowParse.Bytes.bytes ->
b2: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.length b1 == sz /\
(let vlen =
LowParse.Spec.Base.parse (LowParse.Spec.BoundedInt.parse_bounded_integer sz) b1
in
Some? vlen /\
(let _ = vlen in
(let FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ len _) =
_
in
f len == true /\ FStar.Seq.Base.length b2 == FStar.UInt32.v len /\
(let vv = LowParse.Spec.Base.parse p b2 in
Some? vv /\
(let _ = vv in
(let
FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ _ consumed) =
_
in
consumed == FStar.Seq.Base.length b2 /\
FStar.Seq.Base.length b1 <= FStar.Seq.Base.length b /\
FStar.Seq.Base.slice b 0 (FStar.Seq.Base.length b1) == b1 /\
FStar.Seq.Base.slice b (FStar.Seq.Base.length b1) (FStar.Seq.Base.length b) ==
b2)
<:
Prims.logical)))
<:
Prims.logical)))
(ensures
(let vv = LowParse.Spec.Base.parse p b2 in
Some? vv /\
(let _ = vv in
(let FStar.Pervasives.Native.Some #_ (FStar.Pervasives.Native.Mktuple2 #_ #_ v consumed)
=
_
in
let vv' = LowParse.Spec.Base.parse (LowParse.Spec.VLData.parse_vldata_gen sz f p) b in
Some? vv' /\
(let _ = vv' in
(let
FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ v' consumed') =
_
in
v == v' /\ consumed == FStar.Seq.Base.length b2 /\
consumed' == FStar.Seq.Base.length b)
<:
Prims.logical))
<:
Prims.logical))) | {
"end_col": 30,
"end_line": 535,
"start_col": 8,
"start_line": 526
} |
FStar.Pervasives.Lemma | val parse_bounded_vldata_elim'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures
(let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
))) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l) | val parse_bounded_vldata_elim'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures
(let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
)))
let parse_bounded_vldata_elim'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures
(let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
))) = | false | null | true | parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l) | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.BoundedInt.parse_bounded_integer_kind",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"Prims.unit",
"LowParse.Spec.VLData.parse_vldata_gen_eq",
"LowParse.Spec.BoundedInt.in_bounds",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.parse",
"LowParse.Spec.VLData.parse_vldata_gen",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Prims.squash",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.UInt32.v",
"Prims.op_Subtraction",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"Prims.op_Addition",
"Prims.logical",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"LowParse.Spec.BoundedInt.integer_size",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_bounded_vldata_elim'
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures
(let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\
(let Some (len, consumed_len) = plen in
(consumed_len <: nat) == (sz <: nat) /\ in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\
(let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\
(let Some (x', consumed_p) = pp in
x' == x /\ (consumed_p <: nat) == U32.v len /\ (consumed <: nat) == sz + U32.v len))
))) | [] | LowParse.Spec.VLData.parse_bounded_vldata_elim' | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
p: LowParse.Spec.Base.parser k t ->
xbytes: LowParse.Bytes.bytes ->
x: t ->
consumed: LowParse.Spec.Base.consumed_length xbytes
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.Base.parse (LowParse.Spec.VLData.parse_vldata_gen l
(LowParse.Spec.BoundedInt.in_bounds min max)
p)
xbytes ==
FStar.Pervasives.Native.Some (x, consumed))
(ensures
(let sz = l in
let plen =
LowParse.Spec.Base.parse (LowParse.Spec.BoundedInt.parse_bounded_integer sz) xbytes
in
Some? plen /\
(let _ = plen in
(let
FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ len consumed_len) =
_
in
consumed_len == sz /\ LowParse.Spec.BoundedInt.in_bounds min max len /\
FStar.UInt32.v len <= FStar.Seq.Base.length xbytes - sz /\
(let input' = FStar.Seq.Base.slice xbytes sz (sz + FStar.UInt32.v len) in
let pp = LowParse.Spec.Base.parse p input' in
Some? pp /\
(let _ = pp in
(let
FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ x' consumed_p) =
_
in
x' == x /\ consumed_p == FStar.UInt32.v len /\
consumed == sz + FStar.UInt32.v len)
<:
Prims.logical)))
<:
Prims.logical))) | {
"end_col": 81,
"end_line": 281,
"start_col": 2,
"start_line": 280
} |
FStar.Pervasives.Lemma | val parse_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma (requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
() | val parse_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma (requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma (requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x)) = | false | null | true | parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz:integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) = parse_bounded_vldata_elim min max l p xbytes x consumed in
f ();
let Some (len, _) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
() | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.BoundedInt.bounded_integer",
"Prims.unit",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serializer_correct_implies_complete",
"FStar.Seq.Base.equal",
"FStar.Seq.Base.slice",
"FStar.UInt32.v",
"Prims.op_Addition",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"Prims.l_True",
"Prims.squash",
"FStar.Pervasives.Native.uu___is_Some",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Spec.VLData.parse_bounded_vldata_elim",
"LowParse.Spec.Base.parse",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.VLData.parse_bounded_vldata'",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed))) | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma (requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x)) | [] | LowParse.Spec.VLData.parse_bounded_vldata_strong_correct | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s: LowParse.Spec.Base.serializer p ->
xbytes: LowParse.Bytes.bytes ->
consumed: LowParse.Spec.Base.consumed_length xbytes ->
x: t
-> FStar.Pervasives.Lemma
(requires
LowParse.Spec.Base.parse (LowParse.Spec.VLData.parse_bounded_vldata' min max l p) xbytes ==
FStar.Pervasives.Native.Some (x, consumed))
(ensures LowParse.Spec.VLData.parse_bounded_vldata_strong_pred min max s x) | {
"end_col": 4,
"end_line": 444,
"start_col": 2,
"start_line": 432
} |
FStar.Pervasives.Lemma | val serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma (requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let sy = serialize s y in
let y:parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy
))
= let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let sy = serialize s y in
let sy' = serialize (serialize_bounded_vldata_strong min max s) y in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
assert (lm + Seq.length sy == Seq.length sx');
seq_upd_seq_right sx' sy;
Seq.lemma_split sx' lm;
Seq.lemma_split sy' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
Seq.lemma_append_inj (Seq.slice sy' 0 lm) (Seq.slice sy' lm (Seq.length sy')) sz sy;
assert (sy' `Seq.equal` seq_upd_seq sx' lm sy) | val serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma (requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let sy = serialize s y in
let y:parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy))
let serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma (requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let sy = serialize s y in
let y:parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy)) = | false | null | true | let y:parse_bounded_vldata_strong_t min max s = y in
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let sy = serialize s y in
let sy' = serialize (serialize_bounded_vldata_strong min max s) y in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
assert (lm + Seq.length sy == Seq.length sx');
seq_upd_seq_right sx' sy;
Seq.lemma_split sx' lm;
Seq.lemma_split sy' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
Seq.lemma_append_inj (Seq.slice sy' 0 lm) (Seq.slice sy' lm (Seq.length sy')) sz sy;
assert (sy' `Seq.equal` (seq_upd_seq sx' lm sy)) | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"Prims._assert",
"FStar.Seq.Base.equal",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.seq_upd_seq",
"Prims.unit",
"FStar.Seq.Properties.lemma_append_inj",
"FStar.Seq.Base.slice",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.lemma_split",
"LowParse.Spec.Base.seq_upd_seq_right",
"Prims.eq2",
"Prims.int",
"Prims.op_Addition",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.BoundedInt.parse_bounded_integer_kind",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.BoundedInt.serialize_bounded_integer",
"FStar.UInt32.uint_to_t",
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong",
"Prims.squash",
"FStar.Seq.Base.seq",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b
let serialize_vldata_gen_correct
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) (Seq.append b1 b2) in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == sz + Seq.length b2
)))) =
seq_slice_append_l b1 b2;
seq_slice_append_r b1 b2;
serialize_vldata_gen_correct_aux sz f p (Seq.append b1 b2) b1 b2
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted == Some (input, Seq.length formatted))
= let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let (len: bounded_integer sz) = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let (Some (len', consumed_len')) = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let (Some (_, consumed_p)) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p
slen
sp
;
()
let serialize_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s))
= Classical.forall_intro (serialize_bounded_vldata_strong_correct min max l s);
serialize_bounded_vldata_strong_aux min max l s
let serialize_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong min max s))
= serialize_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_precond
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(k: parser_kind)
: GTot bool
= match k.parser_kind_high with
| None -> false
| Some max' -> min <= k.parser_kind_low && max' <= max
let serialize_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: Lemma
( let Some (_, consumed) = parse p (serialize s x) in
let y = serialize_bounded_vldata_strong_aux min max (log256' max) s (x <: parse_bounded_vldata_strong_t min max s) in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y))
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_strong_correct min max (log256' max) s x;
()
let serialize_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: GTot (y: bytes { parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y) } )
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_correct min max s x;
serialize_bounded_vldata_strong_aux min max (log256' max) s x
let serialize_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
: Tot (serializer (parse_bounded_vldata min max p))
= serialize_bounded_vldata' min max s
let serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma (requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures
(let sy = serialize s y in
let y:parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy)) | [] | LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
s: LowParse.Spec.Base.serializer p ->
x: LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s ->
y: t
-> FStar.Pervasives.Lemma
(requires
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s y) ==
FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x))
(ensures
(let sy = LowParse.Spec.Base.serialize s y in
let y = y in
let sx =
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
x
in
let lm = LowParse.Spec.BoundedInt.log256' max in
lm + FStar.Seq.Base.length sy == FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
y ==
LowParse.Spec.Base.seq_upd_seq sx lm sy)) | {
"end_col": 50,
"end_line": 712,
"start_col": 1,
"start_line": 699
} |
FStar.Pervasives.Lemma | val parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\
(if f len
then
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len then res == Some (x, sz + U32.v len) else res == None
| _ -> res == None
else res == None)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
() | val parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\
(if f len
then
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len then res == Some (x, sz + U32.v len) else res == None
| _ -> res == None
else res == None))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\
(if f len
then
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len then res == Some (x, sz + U32.v len) else res == None
| _ -> res == None
else res == None)) = | false | null | true | parse_vldata_gen_eq_def sz f p;
and_then_eq #_
#(parse_filter_refine f)
(parse_filter (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p)
input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
() | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.BoundedInt.bounded_integer",
"Prims.bool",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Bytes.bytes",
"Prims.unit",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.BoundedInt.parse_bounded_integer_kind",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.Combinators.parse_filter_eq",
"LowParse.Spec.Combinators.and_then_eq",
"LowParse.Spec.Combinators.parse_filter_kind",
"LowParse.Spec.Combinators.parse_filter_refine",
"LowParse.Spec.Combinators.parse_filter",
"LowParse.Spec.VLData.parse_vldata_payload_kind",
"LowParse.Spec.VLData.parse_vldata_payload",
"LowParse.Spec.VLData.parse_vldata_gen_eq_def",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.Base.parse",
"Prims.eq2",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"FStar.Pervasives.Native.None",
"Prims.l_and",
"Prims.nat",
"Prims.l_or",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"Prims.op_LessThan",
"Prims.op_Addition",
"FStar.UInt32.v",
"Prims.op_Equality",
"Prims.int",
"Prims.op_GreaterThanOrEqual",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"Prims.logical",
"FStar.Seq.Base.seq",
"FStar.Seq.Base.slice",
"LowParse.Spec.VLData.parse_vldata_gen",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\
(if f len
then
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len then res == Some (x, sz + U32.v len) else res == None
| _ -> res == None
else res == None)) | [] | LowParse.Spec.VLData.parse_vldata_gen_eq | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
sz: LowParse.Spec.BoundedInt.integer_size ->
f: (_: LowParse.Spec.BoundedInt.bounded_integer sz -> Prims.GTot Prims.bool) ->
p: LowParse.Spec.Base.parser k t ->
input: LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(ensures
(let res = LowParse.Spec.Base.parse (LowParse.Spec.VLData.parse_vldata_gen sz f p) input in
(match
LowParse.Spec.Base.parse (LowParse.Spec.BoundedInt.parse_bounded_integer sz) input
with
| FStar.Pervasives.Native.None #_ -> res == FStar.Pervasives.Native.None
| FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ len consumed_len) ->
consumed_len == sz /\
(match f len with
| true ->
(match FStar.Seq.Base.length input < sz + FStar.UInt32.v len with
| true -> res == FStar.Pervasives.Native.None
| _ ->
let input' = FStar.Seq.Base.slice input sz (sz + FStar.UInt32.v len) in
(match LowParse.Spec.Base.parse p input' with
| FStar.Pervasives.Native.Some
#_
(FStar.Pervasives.Native.Mktuple2 #_ #_ x consumed_x) ->
(match consumed_x = FStar.UInt32.v len with
| true -> res == FStar.Pervasives.Native.Some (x, sz + FStar.UInt32.v len)
| _ -> res == FStar.Pervasives.Native.None)
<:
Prims.logical
| _ -> res == FStar.Pervasives.Native.None)
<:
Prims.logical)
<:
Prims.logical
| _ -> res == FStar.Pervasives.Native.None))
<:
Type0)) | {
"end_col": 4,
"end_line": 155,
"start_col": 2,
"start_line": 151
} |
FStar.Pervasives.Lemma | val serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted ==
Some (input, Seq.length formatted)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted == Some (input, Seq.length formatted))
= let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let (len: bounded_integer sz) = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let (Some (len', consumed_len')) = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let (Some (_, consumed_p)) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p
slen
sp
;
() | val serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted ==
Some (input, Seq.length formatted))
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted ==
Some (input, Seq.length formatted)) = | false | null | true | let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let len:bounded_integer sz = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let Some (len', consumed_len') = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let Some (_, consumed_p) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p slen sp;
() | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.Base.consumed_length",
"Prims.unit",
"LowParse.Spec.VLData.serialize_vldata_gen_correct",
"LowParse.Spec.BoundedInt.in_bounds",
"Prims._assert",
"Prims.eq2",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"FStar.Pervasives.Native.option",
"FStar.Pervasives.Native.tuple2",
"FStar.Pervasives.Native.uu___is_Some",
"LowParse.Spec.Base.parse",
"Prims.int",
"Prims.l_or",
"FStar.UInt.size",
"FStar.UInt32.n",
"FStar.UInt32.v",
"Prims.bool",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.BoundedInt.parse_bounded_integer_kind",
"LowParse.Spec.BoundedInt.serialize_bounded_integer",
"Prims.pow2",
"FStar.Mul.op_Star",
"FStar.Math.Lemmas.pow2_le_compat",
"FStar.UInt32.t",
"FStar.UInt32.uint_to_t",
"Prims.l_True",
"Prims.squash",
"LowParse.Spec.VLData.parse_bounded_vldata_strong'",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.Mktuple2",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_aux",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b
let serialize_vldata_gen_correct
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) (Seq.append b1 b2) in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == sz + Seq.length b2
)))) =
seq_slice_append_l b1 b2;
seq_slice_append_r b1 b2;
serialize_vldata_gen_correct_aux sz f p (Seq.append b1 b2) b1 b2
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted ==
Some (input, Seq.length formatted)) | [] | LowParse.Spec.VLData.serialize_bounded_vldata_strong_correct | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
s: LowParse.Spec.Base.serializer p ->
input: LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s
-> FStar.Pervasives.Lemma
(ensures
(let formatted = LowParse.Spec.VLData.serialize_bounded_vldata_strong_aux min max l s input in
LowParse.Spec.Base.parse (LowParse.Spec.VLData.parse_bounded_vldata_strong' min max l s)
formatted ==
FStar.Pervasives.Native.Some (input, FStar.Seq.Base.length formatted))) | {
"end_col": 4,
"end_line": 608,
"start_col": 1,
"start_line": 584
} |
FStar.Pervasives.Lemma | val parse_bounded_vldata_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k)
(parse_vldata_gen l (in_bounds min max) p)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf) | val parse_bounded_vldata_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k)
(parse_vldata_gen l (in_bounds min max) p))
let parse_bounded_vldata_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k)
(parse_vldata_gen l (in_bounds min max) p)) = | false | null | true | parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k)
(parse_vldata_gen l (in_bounds min max) p);
let sz:integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf (input: bytes)
: Lemma (requires (Some? (parse p' input)))
(ensures
(let pi = parse p' input in
Some? pi /\
(let Some (_, consumed) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high))) =
let Some (data, consumed) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf) | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"Prims.op_GreaterThanOrEqual",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"FStar.Classical.forall_intro",
"LowParse.Bytes.bytes",
"Prims.l_imp",
"FStar.Pervasives.Native.uu___is_Some",
"FStar.Pervasives.Native.tuple2",
"LowParse.Spec.Base.consumed_length",
"LowParse.Spec.Base.parse",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_low",
"FStar.Pervasives.Native.__proj__Some__item__v",
"LowParse.Spec.Base.__proj__Mkparser_kind'__item__parser_kind_high",
"Prims.logical",
"FStar.Classical.move_requires",
"Prims.unit",
"Prims.squash",
"Prims.Nil",
"FStar.Pervasives.pattern",
"LowParse.Spec.VLData.parse_bounded_vldata_elim'",
"FStar.Pervasives.Native.option",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.Base.parser_kind_prop_equiv",
"LowParse.Spec.Base.get_parser_kind",
"LowParse.Spec.VLData.parse_vldata_gen_kind",
"LowParse.Spec.VLData.parse_vldata_gen",
"LowParse.Spec.BoundedInt.in_bounds",
"LowParse.Spec.BoundedInt.integer_size",
"Prims.l_True",
"LowParse.Spec.Base.parser_kind_prop"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_bounded_vldata_correct
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(l: nat{l >= log256' max /\ l <= 4})
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k)
(parse_vldata_gen l (in_bounds min max) p)) | [] | LowParse.Spec.VLData.parse_bounded_vldata_correct | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
l: Prims.nat{l >= LowParse.Spec.BoundedInt.log256' max /\ l <= 4} ->
p: LowParse.Spec.Base.parser k t
-> FStar.Pervasives.Lemma
(ensures
LowParse.Spec.Base.parser_kind_prop (LowParse.Spec.VLData.parse_bounded_vldata_strong_kind min
max
l
k)
(LowParse.Spec.VLData.parse_vldata_gen l (LowParse.Spec.BoundedInt.in_bounds min max) p)) | {
"end_col": 54,
"end_line": 312,
"start_col": 2,
"start_line": 292
} |
FStar.Pervasives.Lemma | val serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s')
)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
parse_bounded_vldata_strong_pred min max s y /\ (
let y : parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s'
)))
= serialize_bounded_vldata_strong_upd min max s x y;
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
seq_upd_seq_right_to_left sx' lm sx i' s';
Seq.lemma_split sx' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
seq_upd_seq_seq_upd_seq_slice sx' lm (Seq.length sx') i' s' | val serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s')
))
let serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s')
)) = | false | null | true | serialize_bounded_vldata_strong_upd min max s x y;
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
seq_upd_seq_right_to_left sx' lm sx i' s';
Seq.lemma_split sx' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
seq_upd_seq_seq_upd_seq_slice sx' lm (Seq.length sx') i' s' | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Bytes.bytes",
"LowParse.Spec.Base.seq_upd_seq_seq_upd_seq_slice",
"LowParse.Bytes.byte",
"FStar.Seq.Base.length",
"Prims.unit",
"FStar.Seq.Properties.lemma_append_inj",
"FStar.Seq.Base.slice",
"FStar.Seq.Properties.lemma_split",
"LowParse.Spec.Base.seq_upd_seq_right_to_left",
"LowParse.Spec.Base.serialize",
"LowParse.Spec.BoundedInt.parse_bounded_integer_kind",
"LowParse.Spec.BoundedInt.bounded_integer",
"LowParse.Spec.BoundedInt.parse_bounded_integer",
"LowParse.Spec.BoundedInt.serialize_bounded_integer",
"FStar.UInt32.uint_to_t",
"LowParse.Spec.BoundedInt.integer_size",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd",
"Prims.op_Addition",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Spec.Base.seq_upd_seq",
"Prims.squash",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"Prims.int",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b
let serialize_vldata_gen_correct
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) (Seq.append b1 b2) in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == sz + Seq.length b2
)))) =
seq_slice_append_l b1 b2;
seq_slice_append_r b1 b2;
serialize_vldata_gen_correct_aux sz f p (Seq.append b1 b2) b1 b2
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted == Some (input, Seq.length formatted))
= let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let (len: bounded_integer sz) = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let (Some (len', consumed_len')) = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let (Some (_, consumed_p)) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p
slen
sp
;
()
let serialize_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s))
= Classical.forall_intro (serialize_bounded_vldata_strong_correct min max l s);
serialize_bounded_vldata_strong_aux min max l s
let serialize_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong min max s))
= serialize_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_precond
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(k: parser_kind)
: GTot bool
= match k.parser_kind_high with
| None -> false
| Some max' -> min <= k.parser_kind_low && max' <= max
let serialize_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: Lemma
( let Some (_, consumed) = parse p (serialize s x) in
let y = serialize_bounded_vldata_strong_aux min max (log256' max) s (x <: parse_bounded_vldata_strong_t min max s) in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y))
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_strong_correct min max (log256' max) s x;
()
let serialize_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: GTot (y: bytes { parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y) } )
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_correct min max s x;
serialize_bounded_vldata_strong_aux min max (log256' max) s x
let serialize_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
: Tot (serializer (parse_bounded_vldata min max p))
= serialize_bounded_vldata' min max s
let serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy
))
= let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let sy = serialize s y in
let sy' = serialize (serialize_bounded_vldata_strong min max s) y in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
assert (lm + Seq.length sy == Seq.length sx');
seq_upd_seq_right sx' sy;
Seq.lemma_split sx' lm;
Seq.lemma_split sy' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
Seq.lemma_append_inj (Seq.slice sy' 0 lm) (Seq.slice sy' lm (Seq.length sy')) sz sy;
assert (sy' `Seq.equal` seq_upd_seq sx' lm sy)
let serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy
))
= serialize_bounded_vldata_strong_upd min max s x y
let serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
parse_bounded_vldata_strong_pred min max s y /\ (
let y : parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s' | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s')
)) | [] | LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd_chain | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
s: LowParse.Spec.Base.serializer p ->
x: LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s ->
y: t ->
i': Prims.nat ->
s': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
(let sx = LowParse.Spec.Base.serialize s x in
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize s y == LowParse.Spec.Base.seq_upd_seq sx i' s'))
(ensures
LowParse.Spec.VLData.parse_bounded_vldata_strong_pred min max s y /\
(let y = y in
let sx' =
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
x
in
let lm = LowParse.Spec.BoundedInt.log256' max in
lm + FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.Seq.Base.length sx' /\
lm + i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx' /\
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
y ==
LowParse.Spec.Base.seq_upd_seq sx' (lm + i') s')) | {
"end_col": 61,
"end_line": 769,
"start_col": 2,
"start_line": 761
} |
FStar.Pervasives.Lemma | val serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s'))) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
parse_bounded_vldata_strong_pred min max s y /\ (
let y : parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s'
)))
= serialize_bounded_vldata_strong_upd_chain min max s x y (Seq.length (serialize s x) - i' - Seq.length s') s' | val serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s')))
let serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s'))) = | false | null | true | serialize_bounded_vldata_strong_upd_chain min
max
s
x
y
(Seq.length (serialize s x) - i' - Seq.length s')
s' | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [
"lemma"
] | [
"Prims.nat",
"Prims.l_and",
"Prims.b2t",
"Prims.op_LessThanOrEqual",
"Prims.op_GreaterThan",
"Prims.op_LessThan",
"LowParse.Spec.Base.parser_kind",
"LowParse.Spec.Base.parser",
"LowParse.Spec.Base.serializer",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_t",
"LowParse.Bytes.bytes",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd_chain",
"Prims.op_Subtraction",
"FStar.Seq.Base.length",
"LowParse.Bytes.byte",
"LowParse.Spec.Base.serialize",
"Prims.unit",
"Prims.op_Addition",
"Prims.eq2",
"FStar.Seq.Base.seq",
"LowParse.Spec.Base.seq_upd_bw_seq",
"Prims.squash",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_pred",
"Prims.int",
"LowParse.Spec.VLData.parse_bounded_vldata_strong_kind",
"LowParse.Spec.BoundedInt.log256'",
"LowParse.Spec.VLData.parse_bounded_vldata_strong",
"LowParse.Spec.VLData.serialize_bounded_vldata_strong",
"LowParse.Spec.BoundedInt.integer_size",
"Prims.Nil",
"FStar.Pervasives.pattern"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295
#reset-options
// unfold
let parse_vldata_payload_kind
(sz: integer_size)
(k: parser_kind)
: parser_kind
= strong_parser_kind 0 (parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_payload
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(i: bounded_integer sz { f i == true } )
: Tot (parser (parse_vldata_payload_kind sz k) t)
= weaken (parse_vldata_payload_kind sz k) (parse_fldata p (U32.v i))
#set-options "--z3rlimit 64"
let parse_fldata_and_then_cases_injective
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p))
= parser_kind_prop_equiv k p;
let g
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1 b2: bytes)
: Lemma
(requires (and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2))
(ensures (len1 == len2))
= assert (injective_precond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (injective_postcond p (Seq.slice b1 0 (U32.v len1)) (Seq.slice b2 0 (U32.v len2)));
assert (len1 == len2)
in
let g'
(len1 len2: (len: bounded_integer sz { f len == true } ))
(b1: bytes)
: Lemma
(forall (b2: bytes) . and_then_cases_injective_precond (parse_vldata_payload sz f p) len1 len2 b1 b2 ==> len1 == len2)
= Classical.forall_intro (Classical.move_requires (g len1 len2 b1))
in
Classical.forall_intro_3 g'
#reset-options
// unfold
let parse_vldata_gen_kind
(sz: integer_size)
(k: parser_kind)
: Tot parser_kind
= strong_parser_kind sz (sz + parse_vldata_payload_size sz) (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_vldata_gen_kind_correct
(sz: integer_size)
(k: parser_kind)
: Lemma
( (parse_vldata_gen_kind sz k) == (and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k)))
= let kl = parse_vldata_gen_kind sz k in
let kr = and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) in
assert_norm (kl == kr)
val parse_vldata_gen
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_vldata_gen_kind sz k) t)
val parse_vldata_gen_eq_def
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(and_then_cases_injective (parse_vldata_payload sz f p) /\
parse_vldata_gen_kind sz k == and_then_kind (parse_filter_kind (parse_bounded_integer_kind sz)) (parse_vldata_payload_kind sz k) /\
parse_vldata_gen sz f p ==
and_then
#_
#(parse_filter_refine #(bounded_integer sz) f)
(parse_filter #_ #(bounded_integer sz) (parse_bounded_integer sz) f)
#_
#t
(parse_vldata_payload sz f p))
let parse_vldata_gen_eq
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(let res = parse (parse_vldata_gen sz f p) input in
match parse (parse_bounded_integer sz) input with
| None -> res == None
| Some (len, consumed_len) ->
consumed_len == sz /\ (
if f len
then begin
if Seq.length input < sz + U32.v len
then res == None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then res == Some (x, sz + U32.v len)
else res == None
| _ -> res == None
end
else res == None
))
= parse_vldata_gen_eq_def sz f p;
and_then_eq #_ #(parse_filter_refine f) (parse_filter (parse_bounded_integer sz) f) #_ #t (parse_vldata_payload sz f p) input;
parse_filter_eq #_ #(bounded_integer sz) (parse_bounded_integer sz) f input;
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
()
let parse_vldata_gen_eq_some_elim
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(requires (Some? (parse (parse_vldata_gen sz f p) input)))
(ensures (
let pbi = parse (parse_bounded_integer sz) input in
Some? pbi /\ (
let Some (len, consumed_len) = pbi in
consumed_len == sz /\
f len /\
Seq.length input >= sz + U32.v len /\ (
let input' = Seq.slice input sz (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let Some (x, consumed_x) = pp in
consumed_x = U32.v len /\
parse (parse_vldata_gen sz f p) input == Some (x, sz + U32.v len)
)))))
= parse_vldata_gen_eq sz f p input
let unconstrained_bounded_integer
(sz: integer_size)
(i: bounded_integer sz)
: GTot bool
= true
let parse_vldata
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser _ t)
= parse_vldata_gen sz (unconstrained_bounded_integer sz) p
let parse_vldata_eq
(sz: integer_size)
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(input: bytes)
: Lemma
(parse (parse_vldata sz p) input == (match parse (parse_bounded_integer sz) input with
| None -> None
| Some (len, _) ->
begin
if Seq.length input < sz + U32.v len
then None
else
let input' = Seq.slice input sz (sz + U32.v len) in
match parse p input' with
| Some (x, consumed_x) ->
if consumed_x = U32.v len
then Some (x, sz + U32.v len)
else None
| _ -> None
end
))
= parse_vldata_gen_eq sz (unconstrained_bounded_integer _) p input
(** Explicit bounds on size *)
#reset-options
inline_for_extraction
let parse_bounded_vldata_strong_kind
(min: nat)
(max: nat)
(l: nat)
(k: parser_kind)
: Pure parser_kind
(requires (min <= max /\ max > 0 /\ max < 4294967296 /\ l >= log256' max /\ l <= 4 ))
(ensures (fun _ -> True))
= [@inline_let]
let kmin = k.parser_kind_low in
[@inline_let]
let min' = if kmin > min then kmin else min in
[@inline_let]
let max' = match k.parser_kind_high with
| None -> max
| Some kmax -> if kmax < max then kmax else max
in
[@inline_let]
let max' = if max' < min' then min' else max' in
(* the size of the length prefix must conform to the max bound given by the user, not on the metadata *)
strong_parser_kind (l + min') (l + max') (
match k.parser_kind_metadata with
| Some ParserKindMetadataFail -> Some ParserKindMetadataFail
| _ -> None
)
let parse_bounded_vldata_elim'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_vldata_gen l (in_bounds min max) p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_vldata_gen_eq l (in_bounds min max) p xbytes;
parser_kind_prop_equiv (parse_bounded_integer_kind l) (parse_bounded_integer l)
let parse_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Lemma
(parser_kind_prop (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p))
= parser_kind_prop_equiv (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p);
let sz : integer_size = l in
let p' = parse_vldata_gen sz (in_bounds min max) p in
parser_kind_prop_equiv (get_parser_kind p') p';
parser_kind_prop_equiv k p;
let k' = parse_bounded_vldata_strong_kind min max l k in
let prf
(input: bytes)
: Lemma
(requires (Some? (parse p' input)))
(ensures (
let pi = parse p' input in
Some? pi /\ (
let (Some (_, consumed)) = pi in
k'.parser_kind_low <= (consumed <: nat) /\
(consumed <: nat) <= Some?.v k'.parser_kind_high
)))
= let (Some (data, consumed)) = parse p' input in
parse_bounded_vldata_elim' min max l p input data consumed
in
Classical.forall_intro (Classical.move_requires prf)
let parse_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) t)
= parse_bounded_vldata_correct min max l p;
strengthen (parse_bounded_vldata_strong_kind min max l k) (parse_vldata_gen l (in_bounds min max) p)
let parse_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) t)
= parse_bounded_vldata' min max (log256' max) p
let parse_bounded_vldata_elim
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
(x: t)
(consumed: consumed_length xbytes)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= parse_bounded_vldata_elim' min max l p xbytes x consumed
let parse_bounded_vldata_elim_forall
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(xbytes: bytes)
: Lemma
(requires (Some? (parse (parse_bounded_vldata' min max l p) xbytes)))
(ensures (
let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
Some? plen /\ (
let (Some (len, consumed_len)) = plen in
(consumed_len <: nat) == (sz <: nat) /\
in_bounds min max len /\
U32.v len <= Seq.length xbytes - sz /\ (
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
let pp = parse p input' in
Some? pp /\ (
let (Some (x', consumed_p)) = pp in
x' == x /\
(consumed_p <: nat) == U32.v len /\
(consumed <: nat) == sz + U32.v len
)))))
= let (Some (x, consumed)) = parse (parse_bounded_vldata' min max l p) xbytes in
parse_bounded_vldata_elim min max l p xbytes x consumed
(* Serialization *)
let parse_bounded_vldata_strong_pred
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: t)
: GTot Type0
= let reslen = Seq.length (s x) in
min <= reslen /\ reslen <= max
let parse_bounded_vldata_strong_t
(min: nat)
(max: nat)
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot Type
= (x: t { parse_bounded_vldata_strong_pred min max s x } )
let parse_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(xbytes: bytes)
(consumed: consumed_length xbytes)
(x: t)
: Lemma
(requires (parse (parse_bounded_vldata' min max l p) xbytes == Some (x, consumed)))
(ensures (parse_bounded_vldata_strong_pred min max s x))
= parse_bounded_vldata_elim min max l p xbytes x consumed;
let sz : integer_size = l in
let plen = parse (parse_bounded_integer sz) xbytes in
let f () : Lemma (Some? plen) =
parse_bounded_vldata_elim min max l p xbytes x consumed
in
f ();
let (Some (len, _)) = plen in
let input' = Seq.slice xbytes (sz <: nat) (sz + U32.v len) in
assert (Seq.equal input' (Seq.slice input' 0 (U32.v len)));
serializer_correct_implies_complete p s;
assert (s x == input');
()
let parse_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max l k) (parse_bounded_vldata_strong_t min max s))
= // strengthen (parse_bounded_vldata_strong_kind min max k)
(
coerce_parser
(parse_bounded_vldata_strong_t min max s)
(parse_strengthen (parse_bounded_vldata' min max l p) (parse_bounded_vldata_strong_pred min max s) (parse_bounded_vldata_strong_correct min max l s))
)
let parse_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (parser (parse_bounded_vldata_strong_kind min max (log256' max) k) (parse_bounded_vldata_strong_t min max s))
= parse_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_strong_aux
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (bare_serializer (parse_bounded_vldata_strong_t min max s))
= (fun (x: parse_bounded_vldata_strong_t min max s) ->
let pl = s x in
let sz = l in
let nlen = Seq.length pl in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
let slen = serialize (serialize_bounded_integer sz) len in
seq_slice_append_l slen pl;
seq_slice_append_r slen pl;
Seq.append slen pl
)
let serialize_vldata_gen_correct_aux
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2 /\
Seq.length b1 <= Seq.length b /\
Seq.slice b 0 (Seq.length b1) == b1 /\
Seq.slice b (Seq.length b1) (Seq.length b) == b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) b in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == Seq.length b
)))) =
let (Some (len, consumed1)) = parse (parse_bounded_integer sz) b1 in
parser_kind_prop_equiv (parse_bounded_integer_kind sz) (parse_bounded_integer sz);
assert (consumed1 == sz);
assert (no_lookahead_on (parse_bounded_integer sz) b1 b);
assert (injective_postcond (parse_bounded_integer sz) b1 b);
assert (parse (parse_bounded_integer sz) b == Some (len, sz));
assert (sz + U32.v len == Seq.length b);
assert (b2 == Seq.slice b sz (sz + U32.v len));
parse_vldata_gen_eq sz f p b
let serialize_vldata_gen_correct
(sz: integer_size)
(f: (bounded_integer sz -> GTot bool))
(#k: parser_kind)
(#t: Type)
(p: parser k t)
(b1 b2: bytes)
: Lemma
(requires (
Seq.length b1 == sz /\ (
let vlen = parse (parse_bounded_integer sz) b1 in
Some? vlen /\ (
let (Some (len, _)) = vlen in
f len == true /\
Seq.length b2 == U32.v len /\ (
let vv = parse p b2 in
Some? vv /\ (
let (Some (_, consumed)) = vv in
consumed == Seq.length b2
))))))
(ensures (
let vv = parse p b2 in
Some? vv /\ (
let (Some (v, consumed)) = vv in
let vv' = parse (parse_vldata_gen sz f p) (Seq.append b1 b2) in
Some? vv' /\ (
let (Some (v', consumed')) = vv' in
v == v' /\
consumed == Seq.length b2 /\
consumed' == sz + Seq.length b2
)))) =
seq_slice_append_l b1 b2;
seq_slice_append_r b1 b2;
serialize_vldata_gen_correct_aux sz f p (Seq.append b1 b2) b1 b2
let serialize_bounded_vldata_strong_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(input: parse_bounded_vldata_strong_t min max s)
: Lemma
(let formatted = serialize_bounded_vldata_strong_aux min max l s input in
parse (parse_bounded_vldata_strong' min max l s) formatted == Some (input, Seq.length formatted))
= let sz = l in
let sp = serialize s input in
let nlen = Seq.length sp in
assert (min <= nlen /\ nlen <= max);
let len = U32.uint_to_t nlen in
M.pow2_le_compat (FStar.Mul.op_Star 8 sz) (FStar.Mul.op_Star 8 (log256' max));
assert (U32.v len < pow2 (FStar.Mul.op_Star 8 sz));
let (len: bounded_integer sz) = len in
let slen = serialize (serialize_bounded_integer sz) len in
assert (Seq.length slen == sz);
let pslen = parse (parse_bounded_integer sz) slen in
assert (Some? pslen);
let (Some (len', consumed_len')) = pslen in
assert (len == len');
assert (in_bounds min max len' == true);
assert (Seq.length sp == U32.v len);
let psp = parse p sp in
assert (Some? psp);
let (Some (_, consumed_p)) = psp in
assert ((consumed_p <: nat) == Seq.length sp);
serialize_vldata_gen_correct sz (in_bounds min max) p
slen
sp
;
()
let serialize_bounded_vldata_strong'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(l: nat { l >= log256' max /\ l <= 4 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong' min max l s))
= Classical.forall_intro (serialize_bounded_vldata_strong_correct min max l s);
serialize_bounded_vldata_strong_aux min max l s
let serialize_bounded_vldata_strong
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
: Tot (serializer (parse_bounded_vldata_strong min max s))
= serialize_bounded_vldata_strong' min max (log256' max) s
let serialize_bounded_vldata_precond
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(k: parser_kind)
: GTot bool
= match k.parser_kind_high with
| None -> false
| Some max' -> min <= k.parser_kind_low && max' <= max
let serialize_bounded_vldata_correct
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: Lemma
( let Some (_, consumed) = parse p (serialize s x) in
let y = serialize_bounded_vldata_strong_aux min max (log256' max) s (x <: parse_bounded_vldata_strong_t min max s) in
parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y))
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_strong_correct min max (log256' max) s x;
()
let serialize_bounded_vldata'
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
(x: t)
: GTot (y: bytes { parse (parse_bounded_vldata min max p) y == Some (x, Seq.length y) } )
= let Some (_, consumed) = parse p (serialize s x) in
serialize_bounded_vldata_correct min max s x;
serialize_bounded_vldata_strong_aux min max (log256' max) s x
let serialize_bounded_vldata
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p { serialize_bounded_vldata_precond min max k } )
: Tot (serializer (parse_bounded_vldata min max p))
= serialize_bounded_vldata' min max s
let serialize_bounded_vldata_strong_upd
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx lm sy
))
= let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let sy = serialize s y in
let sy' = serialize (serialize_bounded_vldata_strong min max s) y in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
assert (lm + Seq.length sy == Seq.length sx');
seq_upd_seq_right sx' sy;
Seq.lemma_split sx' lm;
Seq.lemma_split sy' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
Seq.lemma_append_inj (Seq.slice sy' 0 lm) (Seq.slice sy' lm (Seq.length sy')) sz sy;
assert (sy' `Seq.equal` seq_upd_seq sx' lm sy)
let serialize_bounded_vldata_strong_upd_bw
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
: Lemma
(requires (Seq.length (serialize s y) == Seq.length (serialize s x)))
(ensures (
let sy = serialize s y in
let y : parse_bounded_vldata_strong_t min max s = y in
let sx = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length sy == Seq.length sx /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx 0 sy
))
= serialize_bounded_vldata_strong_upd min max s x y
let serialize_bounded_vldata_strong_upd_chain
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_seq sx i' s'
))
(ensures (
parse_bounded_vldata_strong_pred min max s y /\ (
let y : parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
lm + i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_seq sx' (lm + i') s'
)))
= serialize_bounded_vldata_strong_upd min max s x y;
let sx = serialize s x in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
let sz = serialize (serialize_bounded_integer lm) (U32.uint_to_t (Seq.length sx)) in
seq_upd_seq_right_to_left sx' lm sx i' s';
Seq.lemma_split sx' lm;
Seq.lemma_append_inj (Seq.slice sx' 0 lm) (Seq.slice sx' lm (Seq.length sx')) sz sx;
seq_upd_seq_seq_upd_seq_slice sx' lm (Seq.length sx') i' s'
#reset-options "--z3refresh --z3rlimit 32 --z3cliopt smt.arith.nl=false"
let serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat { min <= max /\ max > 0 /\ max < 4294967296 } )
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i' : nat)
(s' : bytes)
: Lemma
(requires (
let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\
serialize s y == seq_upd_bw_seq sx i' s'
))
(ensures (
parse_bounded_vldata_strong_pred min max s y /\ (
let y : parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s' | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 32,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val serialize_bounded_vldata_strong_upd_bw_chain
(min: nat)
(max: nat{min <= max /\ max > 0 /\ max < 4294967296})
(#k: parser_kind)
(#t: Type)
(#p: parser k t)
(s: serializer p)
(x: parse_bounded_vldata_strong_t min max s)
(y: t)
(i': nat)
(s': bytes)
: Lemma
(requires
(let sx = serialize s x in
i' + Seq.length s' <= Seq.length sx /\ serialize s y == seq_upd_bw_seq sx i' s'))
(ensures
(parse_bounded_vldata_strong_pred min max s y /\
(let y:parse_bounded_vldata_strong_t min max s = y in
let sx' = serialize (serialize_bounded_vldata_strong min max s) x in
let lm = log256' max in
lm + Seq.length (serialize s x) == Seq.length sx' /\
i' + Seq.length s' <= Seq.length sx' /\
serialize (serialize_bounded_vldata_strong min max s) y == seq_upd_bw_seq sx' i' s'))) | [] | LowParse.Spec.VLData.serialize_bounded_vldata_strong_upd_bw_chain | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
min: Prims.nat ->
max: Prims.nat{min <= max /\ max > 0 /\ max < 4294967296} ->
s: LowParse.Spec.Base.serializer p ->
x: LowParse.Spec.VLData.parse_bounded_vldata_strong_t min max s ->
y: t ->
i': Prims.nat ->
s': LowParse.Bytes.bytes
-> FStar.Pervasives.Lemma
(requires
(let sx = LowParse.Spec.Base.serialize s x in
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx /\
LowParse.Spec.Base.serialize s y == LowParse.Spec.Base.seq_upd_bw_seq sx i' s'))
(ensures
LowParse.Spec.VLData.parse_bounded_vldata_strong_pred min max s y /\
(let y = y in
let sx' =
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
x
in
let lm = LowParse.Spec.BoundedInt.log256' max in
lm + FStar.Seq.Base.length (LowParse.Spec.Base.serialize s x) == FStar.Seq.Base.length sx' /\
i' + FStar.Seq.Base.length s' <= FStar.Seq.Base.length sx' /\
LowParse.Spec.Base.serialize (LowParse.Spec.VLData.serialize_bounded_vldata_strong min
max
s)
y ==
LowParse.Spec.Base.seq_upd_bw_seq sx' i' s')) | {
"end_col": 110,
"end_line": 799,
"start_col": 2,
"start_line": 799
} |
Prims.Pure | val parse_vldata_payload_size (sz: integer_size)
: Pure nat (requires True) (ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1)) | [
{
"abbrev": true,
"full_module": "LowParse.Math",
"short_module": "M"
},
{
"abbrev": true,
"full_module": "FStar.UInt32",
"short_module": "U32"
},
{
"abbrev": true,
"full_module": "FStar.Seq",
"short_module": "Seq"
},
{
"abbrev": false,
"full_module": "LowParse.Spec.AllIntegers",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec.FLData",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.Spec",
"short_module": null
},
{
"abbrev": false,
"full_module": "LowParse.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 parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True)
(ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1 ))
= match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295 | val parse_vldata_payload_size (sz: integer_size)
: Pure nat (requires True) (ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1))
let parse_vldata_payload_size (sz: integer_size)
: Pure nat (requires True) (ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1)) = | false | null | false | match sz with
| 1 -> 255
| 2 -> 65535
| 3 -> 16777215
| 4 -> 4294967295 | {
"checked_file": "LowParse.Spec.VLData.fsti.checked",
"dependencies": [
"prims.fst.checked",
"LowParse.Spec.FLData.fst.checked",
"LowParse.Spec.AllIntegers.fst.checked",
"LowParse.Math.fst.checked",
"FStar.UInt32.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.Classical.fsti.checked"
],
"interface_file": false,
"source_file": "LowParse.Spec.VLData.fsti"
} | [] | [
"LowParse.Spec.BoundedInt.integer_size",
"Prims.nat",
"Prims.l_True",
"Prims.eq2",
"Prims.int",
"Prims.op_Subtraction",
"Prims.pow2",
"FStar.Mul.op_Star"
] | [] | module LowParse.Spec.VLData
include LowParse.Spec.FLData
include LowParse.Spec.AllIntegers // for bounded_integer, in_bounds, etc.
module Seq = FStar.Seq
module U32 = FStar.UInt32
module M = LowParse.Math
#reset-options "--z3rlimit 64 --max_fuel 64 --max_ifuel 64 --z3refresh --z3cliopt smt.arith.nl=false"
let parse_vldata_payload_size
(sz: integer_size)
: Pure nat
(requires True) | false | false | LowParse.Spec.VLData.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 64,
"max_ifuel": 64,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [
"smt.arith.nl=false"
],
"z3refresh": true,
"z3rlimit": 64,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val parse_vldata_payload_size (sz: integer_size)
: Pure nat (requires True) (ensures (fun y -> y == pow2 (FStar.Mul.op_Star 8 sz) - 1)) | [] | LowParse.Spec.VLData.parse_vldata_payload_size | {
"file_name": "src/lowparse/LowParse.Spec.VLData.fsti",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | sz: LowParse.Spec.BoundedInt.integer_size -> Prims.Pure Prims.nat | {
"end_col": 19,
"end_line": 20,
"start_col": 2,
"start_line": 16
} |
Prims.Tot | [
{
"abbrev": false,
"full_module": "FStar.Reflection.Types",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": "X"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Data",
"short_module": "X"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V1",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V1",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ppname_t = FStar.Sealed.Inhabited.sealed "" | let ppname_t = | false | null | false | FStar.Sealed.Inhabited.sealed "" | {
"checked_file": "FStar.Reflection.V1.Data.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Sealed.Inhabited.fst.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.Reflection.Types.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Reflection.V1.Data.fsti"
} | [
"total"
] | [
"FStar.Sealed.Inhabited.sealed",
"Prims.string"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Reflection.V1.Data
(* What's this!? Well, the compiler now works fully with V2, so whenever
we need to reason/extract a term, we need things like V2.Tv_App and V2.pack_ln
in scope. So, force them into scope here. *)
module X = FStar.Reflection.V2.Data
module X = FStar.Reflection.V2.Builtins
open FStar.Reflection.Types
(* V1 does not really use the primitive ident type, but this
explicit pair of string & range *)
type ident = string & range
type univ_name = ident
noeq
type vconst =
| C_Unit : vconst
| C_Int : int -> vconst // Not exposing the full details of our integer repr.
| C_True : vconst
| C_False : vconst
| C_String : string -> vconst
| C_Range : range -> vconst
| C_Reify : vconst
| C_Reflect : name -> vconst
(* TODO: complete *)
type universes = list universe
// This is shadowing `pattern` from Prims (for smt_pats)
noeq
type pattern =
| Pat_Constant : vconst -> pattern // A built-in constant
| Pat_Cons : fv -> option universes -> list (pattern * bool) -> pattern
// A fully applied constructor, each boolean marks
// whether the argument was an explicitly-provided
// implicit argument
| Pat_Var : bv -> sealed typ -> pattern // Pattern bound variable
| Pat_Dot_Term : option term -> pattern // Dot pattern: resolved by other elements in the pattern and type
type branch = pattern * term // | pattern -> term
noeq
type aqualv =
| Q_Implicit
| Q_Explicit
| Q_Meta of term
type argv = term * aqualv
(* The type of a string observable only with a tactic. | false | false | FStar.Reflection.V1.Data.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val ppname_t : Type0 | [] | FStar.Reflection.V1.Data.ppname_t | {
"file_name": "ulib/FStar.Reflection.V1.Data.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | Type0 | {
"end_col": 47,
"end_line": 68,
"start_col": 15,
"start_line": 68
} |
|
Prims.Tot | val as_ppname (x: string) : ppname_t | [
{
"abbrev": false,
"full_module": "FStar.Reflection.Types",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": "X"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Data",
"short_module": "X"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V1",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V1",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let as_ppname (x:string) : ppname_t = FStar.Sealed.Inhabited.seal x | val as_ppname (x: string) : ppname_t
let as_ppname (x: string) : ppname_t = | false | null | false | FStar.Sealed.Inhabited.seal x | {
"checked_file": "FStar.Reflection.V1.Data.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Sealed.Inhabited.fst.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.Reflection.Types.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Reflection.V1.Data.fsti"
} | [
"total"
] | [
"Prims.string",
"FStar.Sealed.Inhabited.seal",
"FStar.Reflection.V1.Data.ppname_t"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Reflection.V1.Data
(* What's this!? Well, the compiler now works fully with V2, so whenever
we need to reason/extract a term, we need things like V2.Tv_App and V2.pack_ln
in scope. So, force them into scope here. *)
module X = FStar.Reflection.V2.Data
module X = FStar.Reflection.V2.Builtins
open FStar.Reflection.Types
(* V1 does not really use the primitive ident type, but this
explicit pair of string & range *)
type ident = string & range
type univ_name = ident
noeq
type vconst =
| C_Unit : vconst
| C_Int : int -> vconst // Not exposing the full details of our integer repr.
| C_True : vconst
| C_False : vconst
| C_String : string -> vconst
| C_Range : range -> vconst
| C_Reify : vconst
| C_Reflect : name -> vconst
(* TODO: complete *)
type universes = list universe
// This is shadowing `pattern` from Prims (for smt_pats)
noeq
type pattern =
| Pat_Constant : vconst -> pattern // A built-in constant
| Pat_Cons : fv -> option universes -> list (pattern * bool) -> pattern
// A fully applied constructor, each boolean marks
// whether the argument was an explicitly-provided
// implicit argument
| Pat_Var : bv -> sealed typ -> pattern // Pattern bound variable
| Pat_Dot_Term : option term -> pattern // Dot pattern: resolved by other elements in the pattern and type
type branch = pattern * term // | pattern -> term
noeq
type aqualv =
| Q_Implicit
| Q_Explicit
| Q_Meta of term
type argv = term * aqualv
(* The type of a string observable only with a tactic.
All values of type ppname_t are provably equal *) | false | false | FStar.Reflection.V1.Data.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val as_ppname (x: string) : ppname_t | [] | FStar.Reflection.V1.Data.as_ppname | {
"file_name": "ulib/FStar.Reflection.V1.Data.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | x: Prims.string -> FStar.Reflection.V1.Data.ppname_t | {
"end_col": 67,
"end_line": 69,
"start_col": 38,
"start_line": 69
} |
Prims.Tot | val notAscription (tv: term_view) : bool | [
{
"abbrev": false,
"full_module": "FStar.Reflection.Types",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": "X"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Data",
"short_module": "X"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V1",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V1",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let notAscription (tv:term_view) : bool =
not (Tv_AscribedT? tv) && not (Tv_AscribedC? tv) | val notAscription (tv: term_view) : bool
let notAscription (tv: term_view) : bool = | false | null | false | not (Tv_AscribedT? tv) && not (Tv_AscribedC? tv) | {
"checked_file": "FStar.Reflection.V1.Data.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Sealed.Inhabited.fst.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.Reflection.Types.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Reflection.V1.Data.fsti"
} | [
"total"
] | [
"FStar.Reflection.V1.Data.term_view",
"Prims.op_AmpAmp",
"Prims.op_Negation",
"FStar.Reflection.V1.Data.uu___is_Tv_AscribedT",
"FStar.Reflection.V1.Data.uu___is_Tv_AscribedC",
"Prims.bool"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Reflection.V1.Data
(* What's this!? Well, the compiler now works fully with V2, so whenever
we need to reason/extract a term, we need things like V2.Tv_App and V2.pack_ln
in scope. So, force them into scope here. *)
module X = FStar.Reflection.V2.Data
module X = FStar.Reflection.V2.Builtins
open FStar.Reflection.Types
(* V1 does not really use the primitive ident type, but this
explicit pair of string & range *)
type ident = string & range
type univ_name = ident
noeq
type vconst =
| C_Unit : vconst
| C_Int : int -> vconst // Not exposing the full details of our integer repr.
| C_True : vconst
| C_False : vconst
| C_String : string -> vconst
| C_Range : range -> vconst
| C_Reify : vconst
| C_Reflect : name -> vconst
(* TODO: complete *)
type universes = list universe
// This is shadowing `pattern` from Prims (for smt_pats)
noeq
type pattern =
| Pat_Constant : vconst -> pattern // A built-in constant
| Pat_Cons : fv -> option universes -> list (pattern * bool) -> pattern
// A fully applied constructor, each boolean marks
// whether the argument was an explicitly-provided
// implicit argument
| Pat_Var : bv -> sealed typ -> pattern // Pattern bound variable
| Pat_Dot_Term : option term -> pattern // Dot pattern: resolved by other elements in the pattern and type
type branch = pattern * term // | pattern -> term
noeq
type aqualv =
| Q_Implicit
| Q_Explicit
| Q_Meta of term
type argv = term * aqualv
(* The type of a string observable only with a tactic.
All values of type ppname_t are provably equal *)
let ppname_t = FStar.Sealed.Inhabited.sealed ""
let as_ppname (x:string) : ppname_t = FStar.Sealed.Inhabited.seal x
noeq
type bv_view = {
bv_ppname : ppname_t;
bv_index : nat;
}
noeq
type binder_view = {
binder_bv : bv;
binder_qual : aqualv;
binder_attrs : list term;
binder_sort : typ;
}
noeq
type universe_view =
| Uv_Zero : universe_view
| Uv_Succ : universe -> universe_view
| Uv_Max : universes -> universe_view
| Uv_BVar : nat -> universe_view
| Uv_Name : univ_name -> universe_view
| Uv_Unif : universe_uvar -> universe_view
| Uv_Unk : universe_view
noeq
type term_view =
| Tv_Var : v:bv -> term_view
| Tv_BVar : v:bv -> term_view
| Tv_FVar : v:fv -> term_view
| Tv_UInst : v:fv -> us:universes -> term_view
| Tv_App : hd:term -> a:argv -> term_view
| Tv_Abs : bv:binder -> body:term -> term_view
| Tv_Arrow : bv:binder -> c:comp -> term_view
| Tv_Type : universe -> term_view
| Tv_Refine : bv:bv -> sort:typ -> ref:term -> term_view
| Tv_Const : vconst -> term_view
| Tv_Uvar : nat -> ctx_uvar_and_subst -> term_view
| Tv_Let : recf:bool -> attrs:(list term) -> bv:bv -> ty:typ -> def:term -> body:term -> term_view
| Tv_Match : scrutinee:term -> ret:option match_returns_ascription -> brs:(list branch) -> term_view
| Tv_AscribedT : e:term -> t:term -> tac:option term -> use_eq:bool -> term_view
| Tv_AscribedC : e:term -> c:comp -> tac:option term -> use_eq:bool -> term_view
| Tv_Unknown : term_view // An underscore: _
| Tv_Unsupp : term_view // failed to inspect, not supported | false | false | FStar.Reflection.V1.Data.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val notAscription (tv: term_view) : bool | [] | FStar.Reflection.V1.Data.notAscription | {
"file_name": "ulib/FStar.Reflection.V1.Data.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | tv: FStar.Reflection.V1.Data.term_view -> Prims.bool | {
"end_col": 50,
"end_line": 116,
"start_col": 2,
"start_line": 116
} |
Prims.Tot | val var:eqtype | [
{
"abbrev": false,
"full_module": "FStar.Reflection.Types",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Builtins",
"short_module": "X"
},
{
"abbrev": true,
"full_module": "FStar.Reflection.V2.Data",
"short_module": "X"
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V1",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Reflection.V1",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let var : eqtype = nat | val var:eqtype
let var:eqtype = | false | null | false | nat | {
"checked_file": "FStar.Reflection.V1.Data.fsti.checked",
"dependencies": [
"prims.fst.checked",
"FStar.Sealed.Inhabited.fst.checked",
"FStar.Reflection.V2.Data.fsti.checked",
"FStar.Reflection.V2.Builtins.fsti.checked",
"FStar.Reflection.Types.fsti.checked",
"FStar.Pervasives.fsti.checked"
],
"interface_file": false,
"source_file": "FStar.Reflection.V1.Data.fsti"
} | [
"total"
] | [
"Prims.nat"
] | [] | (*
Copyright 2008-2018 Microsoft Research
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*)
module FStar.Reflection.V1.Data
(* What's this!? Well, the compiler now works fully with V2, so whenever
we need to reason/extract a term, we need things like V2.Tv_App and V2.pack_ln
in scope. So, force them into scope here. *)
module X = FStar.Reflection.V2.Data
module X = FStar.Reflection.V2.Builtins
open FStar.Reflection.Types
(* V1 does not really use the primitive ident type, but this
explicit pair of string & range *)
type ident = string & range
type univ_name = ident
noeq
type vconst =
| C_Unit : vconst
| C_Int : int -> vconst // Not exposing the full details of our integer repr.
| C_True : vconst
| C_False : vconst
| C_String : string -> vconst
| C_Range : range -> vconst
| C_Reify : vconst
| C_Reflect : name -> vconst
(* TODO: complete *)
type universes = list universe
// This is shadowing `pattern` from Prims (for smt_pats)
noeq
type pattern =
| Pat_Constant : vconst -> pattern // A built-in constant
| Pat_Cons : fv -> option universes -> list (pattern * bool) -> pattern
// A fully applied constructor, each boolean marks
// whether the argument was an explicitly-provided
// implicit argument
| Pat_Var : bv -> sealed typ -> pattern // Pattern bound variable
| Pat_Dot_Term : option term -> pattern // Dot pattern: resolved by other elements in the pattern and type
type branch = pattern * term // | pattern -> term
noeq
type aqualv =
| Q_Implicit
| Q_Explicit
| Q_Meta of term
type argv = term * aqualv
(* The type of a string observable only with a tactic.
All values of type ppname_t are provably equal *)
let ppname_t = FStar.Sealed.Inhabited.sealed ""
let as_ppname (x:string) : ppname_t = FStar.Sealed.Inhabited.seal x
noeq
type bv_view = {
bv_ppname : ppname_t;
bv_index : nat;
}
noeq
type binder_view = {
binder_bv : bv;
binder_qual : aqualv;
binder_attrs : list term;
binder_sort : typ;
}
noeq
type universe_view =
| Uv_Zero : universe_view
| Uv_Succ : universe -> universe_view
| Uv_Max : universes -> universe_view
| Uv_BVar : nat -> universe_view
| Uv_Name : univ_name -> universe_view
| Uv_Unif : universe_uvar -> universe_view
| Uv_Unk : universe_view
noeq
type term_view =
| Tv_Var : v:bv -> term_view
| Tv_BVar : v:bv -> term_view
| Tv_FVar : v:fv -> term_view
| Tv_UInst : v:fv -> us:universes -> term_view
| Tv_App : hd:term -> a:argv -> term_view
| Tv_Abs : bv:binder -> body:term -> term_view
| Tv_Arrow : bv:binder -> c:comp -> term_view
| Tv_Type : universe -> term_view
| Tv_Refine : bv:bv -> sort:typ -> ref:term -> term_view
| Tv_Const : vconst -> term_view
| Tv_Uvar : nat -> ctx_uvar_and_subst -> term_view
| Tv_Let : recf:bool -> attrs:(list term) -> bv:bv -> ty:typ -> def:term -> body:term -> term_view
| Tv_Match : scrutinee:term -> ret:option match_returns_ascription -> brs:(list branch) -> term_view
| Tv_AscribedT : e:term -> t:term -> tac:option term -> use_eq:bool -> term_view
| Tv_AscribedC : e:term -> c:comp -> tac:option term -> use_eq:bool -> term_view
| Tv_Unknown : term_view // An underscore: _
| Tv_Unsupp : term_view // failed to inspect, not supported
let notAscription (tv:term_view) : bool =
not (Tv_AscribedT? tv) && not (Tv_AscribedC? tv)
// Very basic for now
noeq
type comp_view =
| C_Total : ret:typ -> comp_view
| C_GTotal : ret:typ -> comp_view
| C_Lemma : term -> term -> term -> comp_view // pre, post, patterns
| C_Eff : us:universes ->
eff_name:name ->
result:term ->
eff_args:(list argv) ->
decrs:list term ->
comp_view
(* Constructor for an inductive type. See explanation in
[Sg_Inductive] below. *)
type ctor = name & typ
noeq
type lb_view = {
lb_fv : fv;
lb_us : list univ_name;
lb_typ : typ;
lb_def : term
}
noeq
type sigelt_view =
| Sg_Let :
(r:bool) ->
(lbs:list letbinding) ->
sigelt_view
// Sg_Inductive basically coalesces the Sig_bundle used internally,
// where the type definition and its constructors are split.
// While that might be better for typechecking, this is probably better for metaprogrammers
// (no mutually defined types for now)
| Sg_Inductive :
(nm:name) -> // name of the inductive type being defined
(univs:list univ_name) -> // universe variables
(params:binders) -> // parameters
(typ:typ) -> // the type annotation for the inductive, i.e., indices -> Type #u
(cts:list ctor) -> // the constructors, opened with univs and applied to params already
sigelt_view
| Sg_Val :
(nm:name) ->
(univs:list univ_name) ->
(typ:typ) ->
sigelt_view
| Unk
(* Qualifiers for sigelts, see src/FStar.Syntax.Syntax for an explanation. *)
noeq
type qualifier =
| Assumption
| InternalAssumption
| New
| Private
| Unfold_for_unification_and_vcgen
| Visible_default
| Irreducible
| Inline_for_extraction
| NoExtract
| Noeq
| Unopteq
| TotalEffect
| Logic
| Reifiable
| Reflectable of name
| Discriminator of name
| Projector of name * ident
| RecordType of list ident * list ident
| RecordConstructor of list ident * list ident
| Action of name
| ExceptionConstructor
| HasMaskedEffect
| Effect
| OnlyName | false | false | FStar.Reflection.V1.Data.fsti | {
"detail_errors": false,
"detail_hint_replay": false,
"initial_fuel": 2,
"initial_ifuel": 1,
"max_fuel": 8,
"max_ifuel": 2,
"no_plugins": false,
"no_smt": false,
"no_tactics": false,
"quake_hi": 1,
"quake_keep": false,
"quake_lo": 1,
"retry": false,
"reuse_hint_for": null,
"smtencoding_elim_box": false,
"smtencoding_l_arith_repr": "boxwrap",
"smtencoding_nl_arith_repr": "boxwrap",
"smtencoding_valid_elim": false,
"smtencoding_valid_intro": true,
"tcnorm": true,
"trivial_pre_for_unannotated_effectful_fns": true,
"z3cliopt": [],
"z3refresh": false,
"z3rlimit": 5,
"z3rlimit_factor": 1,
"z3seed": 0,
"z3smtopt": [],
"z3version": "4.8.5"
} | null | val var:eqtype | [] | FStar.Reflection.V1.Data.var | {
"file_name": "ulib/FStar.Reflection.V1.Data.fsti",
"git_rev": "f4cbb7a38d67eeb13fbdb2f4fb8a44a65cbcdc1f",
"git_url": "https://github.com/FStarLang/FStar.git",
"project_name": "FStar"
} | Prims.eqtype | {
"end_col": 22,
"end_line": 199,
"start_col": 19,
"start_line": 199
} |
Prims.Tot | val parse_pair (fst snd: parser not_reading) : parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders } | val parse_pair (fst snd: parser not_reading) : parser not_reading
let parse_pair (fst snd: parser not_reading) : parser not_reading = | false | null | false | fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_pair",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
" | false | true | Z3TestGen.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 parse_pair (fst snd: parser not_reading) : parser not_reading | [] | Z3TestGen.parse_pair | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | fst: Z3TestGen.parser Z3TestGen.not_reading -> snd: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 44,
"end_line": 471,
"start_col": 2,
"start_line": 465
} |
Prims.Tot | val wrap_parser (p: parser reading) : parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders } | val wrap_parser (p: parser reading) : parser not_reading
let wrap_parser (p: parser reading) : parser not_reading = | false | null | false | fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.not_reading",
"Z3TestGen.mk_wrap_parser",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mkreading__item__call",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
" | false | true | Z3TestGen.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 wrap_parser (p: parser reading) : parser not_reading | [] | Z3TestGen.wrap_parser | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: Z3TestGen.parser Z3TestGen.reading -> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 44,
"end_line": 374,
"start_col": 2,
"start_line": 370
} |
Prims.Tot | val is_bitwise_op (x: T.op) : Tot (option A.integer_type) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None | val is_bitwise_op (x: T.op) : Tot (option A.integer_type)
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) = | false | null | false | match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a -> Some a
| _ -> None | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Target.op",
"Ast.integer_type",
"FStar.Pervasives.Native.Some",
"FStar.Pervasives.Native.None",
"FStar.Pervasives.Native.option"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x | false | true | Z3TestGen.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 is_bitwise_op (x: T.op) : Tot (option A.integer_type) | [] | Z3TestGen.is_bitwise_op | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | x: Target.op -> FStar.Pervasives.Native.option Ast.integer_type | {
"end_col": 13,
"end_line": 239,
"start_col": 2,
"start_line": 231
} |
Prims.Tot | val prelude:string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
" | val prelude:string
let prelude:string = | false | null | false | "\n(set-option :produce-models true)\n(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))\n(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))\n\n(define-fun parse-empty ((x State)) Result\n (mk-result 0 x)\n)\n\n(declare-fun choose (Int) Int)\n(assert (forall ((i Int))\n (and (<= 0 (choose i)) (< (choose i) 256))\n))\n\n(define-fun parse-false ((x State)) State\n (mk-state -1 (choice-index x))\n)\n\n(define-fun parse-all-bytes ((x State)) State\n (if (<= (input-size x) 0)\n x\n (mk-state 0 (+ (choice-index x) (input-size x)))\n )\n)\n\n(define-fun parse-all-zeros ((x State)) State\n (if (<= (input-size x) 0)\n x\n (mk-state\n (if\n (forall ((j Int))\n (if (and (<= 0 j) (< j (input-size x)))\n (= (choose (+ (choice-index x) j)) 0)\n true\n )\n )\n 0\n -1\n )\n (+ (choice-index x) (input-size x))\n )\n )\n)\n\n(define-fun parse-u8 ((x State)) Result\n (mk-result\n (choose (choice-index x))\n (mk-state (- (input-size x) 1) (+ (choice-index x) 1))\n )\n)\n\n(define-fun parse-u16-be ((x State)) Result\n (mk-result\n (+ (choose (+ 1 (choice-index x)))\n (* 256\n (choose (+ 0 (choice-index x)))\n )\n )\n (mk-state (- (input-size x) 2) (+ (choice-index x) 2))\n )\n)\n\n(define-fun parse-u16-le ((x State)) Result\n (mk-result\n (+ (choose (+ 0 (choice-index x)))\n (* 256\n (choose (+ 1 (choice-index x)))\n )\n )\n (mk-state (- (input-size x) 2) (+ (choice-index x) 2))\n )\n)\n\n(define-fun parse-u32-be ((x State)) Result\n (mk-result\n (+ (choose (+ 3 (choice-index x)))\n (* 256\n (+ (choose (+ 2 (choice-index x)))\n (* 256\n (+ (choose (+ 1 (choice-index x)))\n (* 256\n (choose (+ 0 (choice-index x)))\n )\n )\n )\n )\n )\n )\n (mk-state (- (input-size x) 4) (+ (choice-index x) 4))\n )\n)\n\n(define-fun parse-u32-le ((x State)) Result\n (mk-result\n (+ (choose (+ 0 (choice-index x)))\n (* 256\n (+ (choose (+ 1 (choice-index x)))\n (* 256\n (+ (choose (+ 2 (choice-index x)))\n (* 256\n (choose (+ 3 (choice-index x)))\n )\n )\n )\n )\n )\n )\n (mk-state (- (input-size x) 4) (+ (choice-index x) 4))\n )\n)\n\n(define-fun parse-u64-be ((x State)) Result\n (mk-result\n (+ (choose (+ 7 (choice-index x)))\n (* 256\n (+ (choose (+ 6 (choice-index x)))\n (* 256\n (+ (choose (+ 5 (choice-index x)))\n (* 256\n (+ (choose (+ 4 (choice-index x)))\n (* 256\n (+ (choose (+ 3 (choice-index x)))\n (* 256\n (+ (choose (+ 2 (choice-index x)))\n (* 256\n (+ (choose (+ 1 (choice-index x)))\n (* 256\n (choose (+ 0 (choice-index x)))\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n (mk-state (- (input-size x) 8) (+ (choice-index x) 8))\n )\n)\n\n(define-fun parse-u64-le ((x State)) Result\n (mk-result\n (+ (choose (+ 0 (choice-index x)))\n (* 256\n (+ (choose (+ 1 (choice-index x)))\n (* 256\n (+ (choose (+ 2 (choice-index x)))\n (* 256\n (+ (choose (+ 3 (choice-index x)))\n (* 256\n (+ (choose (+ 4 (choice-index x)))\n (* 256\n (+ (choose (+ 5 (choice-index x)))\n (* 256\n (+ (choose (+ 6 (choice-index x)))\n (* 256\n (choose (+ 7 (choice-index x)))\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n )\n (mk-state (- (input-size x) 8) (+ (choice-index x) 8))\n )\n)\n\n(define-fun-rec pow-2 ((amount Int)) Int\n (if (<= amount 0)\n 1\n (* 2 (pow-2 (- amount 1)))\n )\n)\n\n;; see LowParse.BitFields.get_bitfield_eq\n(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int\n (mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))\n)\n\n;; see EverParse3d.Prelude.StaticHeader\n(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int\n (get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))\n)\n\n(declare-const initial-input-size Int)\n(assert (>= initial-input-size 0))\n(define-fun initial-state () State (mk-state initial-input-size 0))\n\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget | false | true | Z3TestGen.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 prelude:string | [] | Z3TestGen.prelude | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | Prims.string | {
"end_col": 1,
"end_line": 213,
"start_col": 0,
"start_line": 11
} |
Prims.Tot | val mk_parse_list (name rec_call binders body: string) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
" | val mk_parse_list (name rec_call binders body: string) : string
let mk_parse_list (name rec_call binders body: string) : string = | false | null | false | let input = Printf.sprintf "%s-input" name in
"(define-fun-rec " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (if (<= (input-size " ^
input ^ ") 0)\n " ^ input ^ "\n (" ^ rec_call ^ " (" ^ body ^ " " ^ input ^ "))\n )\n)\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string) | false | true | Z3TestGen.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_parse_list (name rec_call binders body: string) : string | [] | Z3TestGen.mk_parse_list | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> rec_call: Prims.string -> binders: Prims.string -> body: Prims.string
-> Prims.string | {
"end_col": 1,
"end_line": 653,
"start_col": 1,
"start_line": 646
} |
FStar.All.ML | val mk_bitwise_op (op: string) (bitvec_args: option string) : ML string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args)) | val mk_bitwise_op (op: string) (bitvec_args: option string) : ML string
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string = | true | null | false | mk_app "bv2int" (Some (mk_app op bitvec_args)) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"FStar.Pervasives.Native.option",
"Z3TestGen.mk_app",
"FStar.Pervasives.Native.Some"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None | false | false | Z3TestGen.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_bitwise_op (op: string) (bitvec_args: option string) : ML string | [] | Z3TestGen.mk_bitwise_op | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | op: Prims.string -> bitvec_args: FStar.Pervasives.Native.option Prims.string
-> FStar.All.ML Prims.string | {
"end_col": 48,
"end_line": 242,
"start_col": 2,
"start_line": 242
} |
Prims.Tot | val smt_type_of_typ (t: T.typ) : Tot string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int" | val smt_type_of_typ (t: T.typ) : Tot string
let smt_type_of_typ (t: T.typ) : Tot string = | false | null | false | match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Target.typ",
"Z3TestGen.arg_type_of_typ",
"FStar.Pervasives.Native.option",
"Z3TestGen.arg_type",
"Prims.string"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None | false | true | Z3TestGen.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 smt_type_of_typ (t: T.typ) : Tot string | [] | Z3TestGen.smt_type_of_typ | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Target.typ -> Prims.string | {
"end_col": 14,
"end_line": 769,
"start_col": 2,
"start_line": 767
} |
Prims.Tot | val leaf_reading_parser (name: string) : parser reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name } | val leaf_reading_parser (name: string) : parser reading
let leaf_reading_parser (name: string) : parser reading = | false | null | false | fun _ _ _ _ -> { call = name } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mkreading",
"Z3TestGen.reading",
"Z3TestGen.parser"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s) | false | true | Z3TestGen.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 leaf_reading_parser (name: string) : parser reading | [] | Z3TestGen.leaf_reading_parser | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> Z3TestGen.parser Z3TestGen.reading | {
"end_col": 32,
"end_line": 340,
"start_col": 2,
"start_line": 340
} |
Prims.Tot | val parse_not_readable_app (hd: A.ident) (args: list I.expr) : Tot (parser not_reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args }) | val parse_not_readable_app (hd: A.ident) (args: list I.expr) : Tot (parser not_reading)
let parse_not_readable_app (hd: A.ident) (args: list I.expr) : Tot (parser not_reading) = | false | null | false | maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args }) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Ast.ident",
"Prims.list",
"InterpreterTarget.expr",
"Z3TestGen.maybe_toplevel_parser",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.not_reading",
"Z3TestGen.mk_app_without_paren",
"Z3TestGen.parser"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr) | false | true | Z3TestGen.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 parse_not_readable_app (hd: A.ident) (args: list I.expr) : Tot (parser not_reading) | [] | Z3TestGen.parse_not_readable_app | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | hd: Ast.ident -> args: Prims.list InterpreterTarget.expr -> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 80,
"end_line": 429,
"start_col": 2,
"start_line": 429
} |
Prims.Tot | val parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: (unit -> ML string))
: parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit) | val parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: (unit -> ML string))
: parser not_reading
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: (unit -> ML string))
: parser not_reading = | false | null | false | parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Ast.ident",
"Prims.unit",
"Prims.string",
"Z3TestGen.parse_dep_pair_with_refinement",
"Z3TestGen.parse_itype",
"InterpreterTarget.Unit",
"Z3TestGen.not_reading"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload | false | false | Z3TestGen.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 parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: (unit -> ML string))
: parser not_reading | [] | Z3TestGen.parse_refine | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tag: Z3TestGen.parser Z3TestGen.reading ->
cond_binder: Ast.ident ->
cond: (_: Prims.unit -> FStar.All.ML Prims.string)
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 86,
"end_line": 523,
"start_col": 2,
"start_line": 523
} |
Prims.Tot | val unsupported_parser (s: string) (a: Type) : Tot (parser a) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s) | val unsupported_parser (s: string) (a: Type) : Tot (parser a)
let unsupported_parser (s: string) (a: Type) : Tot (parser a) = | false | null | false | fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"FStar.All.failwith",
"FStar.Printf.sprintf",
"Z3TestGen.parser"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a | false | false | Z3TestGen.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 unsupported_parser (s: string) (a: Type) : Tot (parser a) | [] | Z3TestGen.unsupported_parser | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: Prims.string -> a: Type -> Z3TestGen.parser a | {
"end_col": 69,
"end_line": 337,
"start_col": 2,
"start_line": 337
} |
Prims.Tot | val count_args (l: list arg_type) : Tot nat | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l) | val count_args (l: list arg_type) : Tot nat
let count_args (l: list arg_type) : Tot nat = | false | null | false | List.Tot.length (List.Tot.filter (function
| ArgPointer -> false
| _ -> true)
l) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.list",
"Z3TestGen.arg_type",
"FStar.List.Tot.Base.length",
"FStar.List.Tot.Base.filter",
"Prims.bool",
"Prims.nat"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness | false | true | Z3TestGen.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 count_args (l: list arg_type) : Tot nat | [] | Z3TestGen.count_args | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | l: Prims.list Z3TestGen.arg_type -> Prims.nat | {
"end_col": 124,
"end_line": 1004,
"start_col": 46,
"start_line": 1004
} |
FStar.All.ML | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_app_without_paren id args =
mk_args_aux None (ident_to_string id) args | let mk_app_without_paren id args = | true | null | false | mk_args_aux None (ident_to_string id) args | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Ast.with_meta_t",
"Ast.ident'",
"Prims.list",
"Target.expr",
"Z3TestGen.mk_args_aux",
"FStar.Pervasives.Native.None",
"Ast.integer_type",
"Z3TestGen.ident_to_string",
"Prims.string"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i) | false | false | Z3TestGen.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_app_without_paren : id: Ast.with_meta_t Ast.ident' -> args: Prims.list Target.expr -> FStar.All.ML Prims.string | [] | Z3TestGen.mk_app_without_paren | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | id: Ast.with_meta_t Ast.ident' -> args: Prims.list Target.expr -> FStar.All.ML Prims.string | {
"end_col": 44,
"end_line": 410,
"start_col": 2,
"start_line": 410
} |
|
Prims.Tot | val parse_dep_pair_with_refinement
(tag: parser reading)
(cond_binder: A.ident)
(cond: (unit -> ML string))
(payload_binder: A.ident)
(payload: parser not_reading)
: parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload | val parse_dep_pair_with_refinement
(tag: parser reading)
(cond_binder: A.ident)
(cond: (unit -> ML string))
(payload_binder: A.ident)
(payload: parser not_reading)
: parser not_reading
let parse_dep_pair_with_refinement
(tag: parser reading)
(cond_binder: A.ident)
(cond: (unit -> ML string))
(payload_binder: A.ident)
(payload: parser not_reading)
: parser not_reading = | false | null | false | parse_dep_pair_with_refinement_gen tag
(ident_to_string cond_binder)
cond
(ident_to_string payload_binder)
payload | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Ast.ident",
"Prims.unit",
"Prims.string",
"Z3TestGen.not_reading",
"Z3TestGen.parse_dep_pair_with_refinement_gen",
"Z3TestGen.ident_to_string"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders } | false | false | Z3TestGen.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 parse_dep_pair_with_refinement
(tag: parser reading)
(cond_binder: A.ident)
(cond: (unit -> ML string))
(payload_binder: A.ident)
(payload: parser not_reading)
: parser not_reading | [] | Z3TestGen.parse_dep_pair_with_refinement | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tag: Z3TestGen.parser Z3TestGen.reading ->
cond_binder: Ast.ident ->
cond: (_: Prims.unit -> FStar.All.ML Prims.string) ->
payload_binder: Ast.ident ->
payload: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 116,
"end_line": 517,
"start_col": 2,
"start_line": 517
} |
Prims.Tot | val parse_dep_pair_with_refinement_gen
(tag: parser reading)
(cond_binder: string)
(cond: (unit -> ML string))
(payload_binder: string)
(payload: parser not_reading)
: parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders } | val parse_dep_pair_with_refinement_gen
(tag: parser reading)
(cond_binder: string)
(cond: (unit -> ML string))
(payload_binder: string)
(payload: parser not_reading)
: parser not_reading
let parse_dep_pair_with_refinement_gen
(tag: parser reading)
(cond_binder: string)
(cond: (unit -> ML string))
(payload_binder: string)
(payload: parser not_reading)
: parser not_reading = | false | null | false | fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name
binders.bind
body_tag.call
cond_binder
(cond ())
payload_binder
body_payload.call);
{ call = mk_function_call name binders } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Prims.string",
"Prims.unit",
"Z3TestGen.not_reading",
"Z3TestGen.binders",
"Prims.bool",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_dep_pair_with_refinement",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mkreading__item__call",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf",
"Z3TestGen.push_binder"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
" | false | false | Z3TestGen.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 parse_dep_pair_with_refinement_gen
(tag: parser reading)
(cond_binder: string)
(cond: (unit -> ML string))
(payload_binder: string)
(payload: parser not_reading)
: parser not_reading | [] | Z3TestGen.parse_dep_pair_with_refinement_gen | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tag: Z3TestGen.parser Z3TestGen.reading ->
cond_binder: Prims.string ->
cond: (_: Prims.unit -> FStar.All.ML Prims.string) ->
payload_binder: Prims.string ->
payload: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 44,
"end_line": 514,
"start_col": 2,
"start_line": 507
} |
Prims.Tot | val parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading)
: parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload | val parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading)
: parser not_reading
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading)
: parser not_reading = | false | null | false | parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Ast.ident",
"Z3TestGen.not_reading",
"Z3TestGen.parse_dep_pair_with_refinement",
"Prims.unit",
"Prims.string"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload | false | true | Z3TestGen.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 parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading)
: parser not_reading | [] | Z3TestGen.parse_dep_pair | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
tag: Z3TestGen.parser Z3TestGen.reading ->
new_binder: Ast.ident ->
payload: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 84,
"end_line": 520,
"start_col": 2,
"start_line": 520
} |
FStar.All.ML | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n" | let witnesses_for
(print_test_case: (Seq.seq int -> list string -> ML unit))
(z3: Z3.z3)
(name: string)
(l: list arg_type)
(nargs: nat{nargs == count_args l})
mk_get_first_witness
mk_want_another_witness
nbwitnesses
= | true | null | false | z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.list",
"Prims.string",
"Prims.unit",
"Z3.Base.z3",
"Z3TestGen.arg_type",
"Prims.nat",
"Prims.eq2",
"Z3TestGen.count_args",
"Z3.Base.__proj__Mkz3__item__to_z3",
"Z3TestGen.want_witnesses"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end | false | false | Z3TestGen.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 witnesses_for : print_test_case:
(_: FStar.Seq.Base.seq Prims.int -> _: Prims.list Prims.string -> FStar.All.ML Prims.unit) ->
z3: Z3.Base.z3 ->
name: Prims.string ->
l: Prims.list Z3TestGen.arg_type ->
nargs: Prims.nat{nargs == Z3TestGen.count_args l} ->
mk_get_first_witness: Prims.string ->
mk_want_another_witness:
(_: FStar.Seq.Base.seq Prims.int -> _: Prims.list Prims.string -> Prims.string) ->
nbwitnesses: Prims.int
-> FStar.All.ML Prims.unit | [] | Z3TestGen.witnesses_for | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
print_test_case:
(_: FStar.Seq.Base.seq Prims.int -> _: Prims.list Prims.string -> FStar.All.ML Prims.unit) ->
z3: Z3.Base.z3 ->
name: Prims.string ->
l: Prims.list Z3TestGen.arg_type ->
nargs: Prims.nat{nargs == Z3TestGen.count_args l} ->
mk_get_first_witness: Prims.string ->
mk_want_another_witness:
(_: FStar.Seq.Base.seq Prims.int -> _: Prims.list Prims.string -> Prims.string) ->
nbwitnesses: Prims.int
-> FStar.All.ML Prims.unit | {
"end_col": 20,
"end_line": 1041,
"start_col": 2,
"start_line": 1038
} |
|
Prims.Tot | val parse_at_most (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes) | val parse_at_most (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading)
let parse_at_most (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) = | false | null | false | parse_exact size (parse_pair body parse_all_bytes) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.unit",
"Prims.string",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Z3TestGen.parse_exact",
"Z3TestGen.parse_pair",
"Z3TestGen.parse_all_bytes"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading) | false | false | Z3TestGen.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 parse_at_most (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | [] | Z3TestGen.parse_at_most | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | size: (_: Prims.unit -> FStar.All.ML Prims.string) -> body: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 52,
"end_line": 591,
"start_col": 2,
"start_line": 591
} |
Prims.Tot | val parse_string (body: parser reading) (terminator: (unit -> ML string)) : Tot (parser not_reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call } | val parse_string (body: parser reading) (terminator: (unit -> ML string)) : Tot (parser not_reading)
let parse_string (body: parser reading) (terminator: (unit -> ML string)) : Tot (parser not_reading) = | false | null | false | fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.reading",
"Prims.unit",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Z3TestGen.Mknot_reading",
"Z3TestGen.not_reading",
"Z3TestGen.mk_parse_string",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mkreading__item__call",
"FStar.Printf.sprintf",
"Z3TestGen.mk_function_call"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string)) | false | false | Z3TestGen.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 parse_string (body: parser reading) (terminator: (unit -> ML string)) : Tot (parser not_reading) | [] | Z3TestGen.parse_string | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | body: Z3TestGen.parser Z3TestGen.reading -> terminator: (_: Prims.unit -> FStar.All.ML Prims.string)
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 23,
"end_line": 702,
"start_col": 2,
"start_line": 697
} |
Prims.Tot | val maybe_toplevel_parser (p: parser not_reading) : parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out | val maybe_toplevel_parser (p: parser not_reading) : parser not_reading
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading = | false | null | false | fun name binders is_toplevel out ->
if is_toplevel
then
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
else p name binders false out | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_toplevel_parser",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
" | false | true | Z3TestGen.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 maybe_toplevel_parser (p: parser not_reading) : parser not_reading | [] | Z3TestGen.maybe_toplevel_parser | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: Z3TestGen.parser Z3TestGen.not_reading -> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 33,
"end_line": 396,
"start_col": 2,
"start_line": 388
} |
FStar.All.ML | val produce_decls (out: (string -> ML unit)) (accu: prog) (l: list I.decl) : ML prog | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l | val produce_decls (out: (string -> ML unit)) (accu: prog) (l: list I.decl) : ML prog
let produce_decls (out: (string -> ML unit)) (accu: prog) (l: list I.decl) : ML prog = | true | null | false | List.fold_left (produce_decl out) accu l | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.unit",
"Z3TestGen.prog",
"Prims.list",
"InterpreterTarget.decl",
"FStar.List.fold_left",
"Z3TestGen.produce_decl"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a | false | false | Z3TestGen.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 produce_decls (out: (string -> ML unit)) (accu: prog) (l: list I.decl) : ML prog | [] | Z3TestGen.produce_decls | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
accu: Z3TestGen.prog ->
l: Prims.list InterpreterTarget.decl
-> FStar.All.ML Z3TestGen.prog | {
"end_col": 42,
"end_line": 819,
"start_col": 2,
"start_line": 819
} |
FStar.All.ML | val print_witness_and_call
(name: string)
(l: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness | val print_witness_and_call
(name: string)
(l: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
let print_witness_and_call
(name: string)
(l: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit = | true | null | false | FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Seq.Base.seq",
"Prims.int",
"Z3TestGen.print_witness",
"Prims.unit",
"FStar.IO.print_string",
"Z3TestGen.mk_witness_call"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu | false | false | Z3TestGen.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 print_witness_and_call
(name: string)
(l: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit | [] | Z3TestGen.print_witness_and_call | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
name: Prims.string ->
l: Prims.list Z3TestGen.arg_type ->
witness: FStar.Seq.Base.seq Prims.int ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | {
"end_col": 23,
"end_line": 1002,
"start_col": 2,
"start_line": 1000
} |
FStar.All.ML | val print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");" | val print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit = | true | null | false | out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.unit",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.nat",
"Prims.string_of_int",
"Z3TestGen.print_witness_args_as_c"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | false | false | Z3TestGen.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 print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | [] | Z3TestGen.print_witness_call_as_c_aux | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
wrapper_name: Prims.string ->
arg_types: Prims.list Z3TestGen.arg_type ->
witness_length: Prims.nat ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | {
"end_col": 10,
"end_line": 902,
"start_col": 2,
"start_line": 897
} |
FStar.All.ML | val print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
" | val print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit = | true | null | false | out "\n {\n BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "\n printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");\n if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");\n if ("
;
if positive then out "!";
out "result)\n return 1;\n };\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.unit",
"Prims.bool",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.nat",
"Z3TestGen.print_witness_call_as_c_aux"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | false | false | Z3TestGen.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 print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit | [] | Z3TestGen.print_witness_call_as_c | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
positive: Prims.bool ->
wrapper_name: Prims.string ->
arg_types: Prims.list Z3TestGen.arg_type ->
witness_length: Prims.nat ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | {
"end_col": 1,
"end_line": 927,
"start_col": 2,
"start_line": 913
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let prog = list (string & list arg_type) | let prog = | false | null | false | list (string & list arg_type) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Prims.string",
"Z3TestGen.arg_type"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> () | false | true | Z3TestGen.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 prog : Type0 | [] | Z3TestGen.prog | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | Type0 | {
"end_col": 40,
"end_line": 804,
"start_col": 11,
"start_line": 804
} |
|
Prims.Tot | val mk_definition (name binders typ body: string) : Tot string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")" | val mk_definition (name binders typ body: string) : Tot string
let mk_definition (name binders typ body: string) : Tot string = | false | null | false | "(define-fun " ^ name ^ " (" ^ binders ^ ") " ^ typ ^ " " ^ body ^ ")" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.op_Hat"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string) | false | true | Z3TestGen.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_definition (name binders typ body: string) : Tot string | [] | Z3TestGen.mk_definition | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> binders: Prims.string -> typ: Prims.string -> body: Prims.string
-> Prims.string | {
"end_col": 56,
"end_line": 781,
"start_col": 2,
"start_line": 781
} |
FStar.All.ML | val with_out_file (#a: Type) (name: string) (body: ((string -> ML unit) -> ML a)) : ML a | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res | val with_out_file (#a: Type) (name: string) (body: ((string -> ML unit) -> ML a)) : ML a
let with_out_file (#a: Type) (name: string) (body: ((string -> ML unit) -> ML a)) : ML a = | true | null | false | let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.unit",
"FStar.IO.close_write_file",
"FStar.IO.write_string",
"FStar.IO.fd_write",
"FStar.IO.open_write_file"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a)) | false | false | Z3TestGen.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 with_out_file (#a: Type) (name: string) (body: ((string -> ML unit) -> ML a)) : ML a | [] | Z3TestGen.with_out_file | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> body: (_: (_: Prims.string -> FStar.All.ML Prims.unit) -> FStar.All.ML a)
-> FStar.All.ML a | {
"end_col": 5,
"end_line": 831,
"start_col": 1,
"start_line": 828
} |
Prims.Tot | val mk_get_first_negative_test_witness (name: string) (l: list arg_type) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_get_first_negative_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^
"
(assert (< state-witness-input-size 0))
" | val mk_get_first_negative_test_witness (name: string) (l: list arg_type) : string
let mk_get_first_negative_test_witness (name: string) (l: list arg_type) : string = | false | null | false | mk_get_witness name l ^ "\n(assert (< state-witness-input-size 0))\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.op_Hat",
"Z3TestGen.mk_get_witness"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n"
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
let mk_get_first_positive_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^ "
(assert (>= state-witness-input-size 0))
"
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args) | false | false | Z3TestGen.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_get_first_negative_test_witness (name: string) (l: list arg_type) : string | [] | Z3TestGen.mk_get_first_negative_test_witness | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> l: Prims.list Z3TestGen.arg_type -> Prims.string | {
"end_col": 1,
"end_line": 1095,
"start_col": 2,
"start_line": 1092
} |
Prims.Tot | val mk_parse_pair (name binders fst snd: string) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
" | val mk_parse_pair (name binders fst snd: string) : string
let mk_parse_pair (name binders fst snd: string) : string = | false | null | false | let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (let ((" ^
tmp ^
" (" ^
fst ^
" " ^
input ^
")))\n (if (< (input-size " ^
tmp ^ ") 0)\n " ^ tmp ^ "\n (" ^ snd ^ " " ^ tmp ^ ")\n )\n )\n )\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string) | false | true | Z3TestGen.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_parse_pair (name binders fst snd: string) : string | [] | Z3TestGen.mk_parse_pair | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> binders: Prims.string -> fst: Prims.string -> snd: Prims.string
-> Prims.string | {
"end_col": 1,
"end_line": 462,
"start_col": 1,
"start_line": 452
} |
FStar.All.ML | val print_witness_args_as_c (out: (string -> ML unit)) (l: list arg_type) (args: list string)
: ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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 print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> () | val print_witness_args_as_c (out: (string -> ML unit)) (l: list arg_type) (args: list string)
: ML unit
let rec print_witness_args_as_c (out: (string -> ML unit)) (l: list arg_type) (args: list string)
: ML unit = | true | null | false | match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U");
out ", ";
print_witness_args_as_c out ql qargs
| _ -> () | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.unit",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Pervasives.Native.Mktuple2",
"Z3TestGen.print_witness_args_as_c",
"Z3TestGen.uu___is_ArgInt",
"Prims.bool",
"FStar.Pervasives.Native.tuple2"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string) | false | false | Z3TestGen.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 print_witness_args_as_c (out: (string -> ML unit)) (l: list arg_type) (args: list string)
: ML unit | [
"recursion"
] | Z3TestGen.print_witness_args_as_c | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
l: Prims.list Z3TestGen.arg_type ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | {
"end_col": 11,
"end_line": 887,
"start_col": 2,
"start_line": 878
} |
Prims.Tot | val mk_parse_ifthenelse (name binders cond f_then f_else: string) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
" | val mk_parse_ifthenelse (name binders cond f_then f_else: string) : string
let mk_parse_ifthenelse (name binders cond f_then f_else: string) : string = | false | null | false | let input = Printf.sprintf "%s-input" name in
"(define-fun " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (if " ^
cond ^ "\n (" ^ f_then ^ " " ^ input ^ ")\n (" ^ f_else ^ " " ^ input ^ ")\n )\n )\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string) | false | false | Z3TestGen.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_parse_ifthenelse (name binders cond f_then f_else: string) : string | [] | Z3TestGen.mk_parse_ifthenelse | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
name: Prims.string ->
binders: Prims.string ->
cond: Prims.string ->
f_then: Prims.string ->
f_else: Prims.string
-> Prims.string | {
"end_col": 1,
"end_line": 539,
"start_col": 1,
"start_line": 532
} |
Prims.Tot | val mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg) | val mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string = | false | null | false | mk_app ("(_ int2bv " ^ string_of_int (integer_type_bit_size t) ^ ")") (Some arg) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Ast.integer_type",
"Prims.string",
"Z3TestGen.mk_app",
"Prims.op_Hat",
"Prims.string_of_int",
"Z3TestGen.integer_type_bit_size",
"FStar.Pervasives.Native.Some"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string | false | true | Z3TestGen.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_bitwise_arg (t: A.integer_type) (arg: string) : Tot string | [] | Z3TestGen.mk_bitwise_arg | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: Ast.integer_type -> arg: Prims.string -> Prims.string | {
"end_col": 78,
"end_line": 284,
"start_col": 2,
"start_line": 284
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let ident_to_string = A.ident_to_string | let ident_to_string = | false | null | false | A.ident_to_string | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Ast.ident_to_string"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s | false | true | Z3TestGen.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 ident_to_string : i: Ast.with_meta_t Ast.ident' -> (Prims.string <: Type0) | [] | Z3TestGen.ident_to_string | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | i: Ast.with_meta_t Ast.ident' -> (Prims.string <: Type0) | {
"end_col": 39,
"end_line": 281,
"start_col": 22,
"start_line": 281
} |
|
Prims.Tot | val push_binder (name typ: string) (b: binders) : binders | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
} | val push_binder (name typ: string) (b: binders) : binders
let push_binder (name typ: string) (b: binders) : binders = | false | null | false | {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args
} | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Z3TestGen.binders",
"Z3TestGen.Mkbinders",
"FStar.Printf.sprintf",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mkbinders__item__args"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
} | false | true | Z3TestGen.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 push_binder (name typ: string) (b: binders) : binders | [] | Z3TestGen.push_binder | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> typ: Prims.string -> b: Z3TestGen.binders -> Z3TestGen.binders | {
"end_col": 44,
"end_line": 323,
"start_col": 2,
"start_line": 321
} |
Prims.Tot | val mk_wrap_parser (name binders body: string) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
" | val mk_wrap_parser (name binders body: string) : string
let mk_wrap_parser (name binders body: string) : string = | false | null | false | let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun " ^
name ^
" (" ^ binders ^ "(" ^ input ^ " State)) State\n (after-state (" ^ body ^ " " ^ input ^ "))\n )\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string) | false | true | Z3TestGen.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_wrap_parser (name binders body: string) : string | [] | Z3TestGen.mk_wrap_parser | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> binders: Prims.string -> body: Prims.string -> Prims.string | {
"end_col": 1,
"end_line": 367,
"start_col": 1,
"start_line": 362
} |
Prims.Tot | val mk_toplevel_parser (name binders body: string) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
" | val mk_toplevel_parser (name binders body: string) : string
let mk_toplevel_parser (name binders body: string) : string = | false | null | false | let input = Printf.sprintf "%s-input" name in
"(define-fun " ^
name ^ " (" ^ binders ^ "(" ^ input ^ " State)) State\n (" ^ body ^ " " ^ input ^ ")\n )\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string) | false | true | Z3TestGen.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_toplevel_parser (name binders body: string) : string | [] | Z3TestGen.mk_toplevel_parser | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> binders: Prims.string -> body: Prims.string -> Prims.string | {
"end_col": 1,
"end_line": 385,
"start_col": 1,
"start_line": 381
} |
Prims.Tot | val parse_readable_itype (i: I.readable_itype) : Tot (parser reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i) | val parse_readable_itype (i: I.readable_itype) : Tot (parser reading)
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) = | false | null | false | leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"InterpreterTarget.readable_itype",
"Z3TestGen.leaf_reading_parser",
"Prims.op_Hat",
"Z3TestGen.readable_itype_parser_suffix",
"Z3TestGen.parser",
"Z3TestGen.reading"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros" | false | true | Z3TestGen.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 parse_readable_itype (i: I.readable_itype) : Tot (parser reading) | [] | Z3TestGen.parse_readable_itype | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | i: InterpreterTarget.readable_itype -> Z3TestGen.parser Z3TestGen.reading | {
"end_col": 65,
"end_line": 355,
"start_col": 2,
"start_line": 355
} |
Prims.Tot | val empty_binders:binders | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
} | val empty_binders:binders
let empty_binders:binders = | false | null | false | { is_empty = true; bind = ""; args = "" } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.Mkbinders"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
} | false | true | Z3TestGen.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 empty_binders:binders | [] | Z3TestGen.empty_binders | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | Z3TestGen.binders | {
"end_col": 12,
"end_line": 317,
"start_col": 2,
"start_line": 315
} |
Prims.Tot | val parse_all_bytes:parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" }) | val parse_all_bytes:parser not_reading
let parse_all_bytes:parser not_reading = | false | null | false | maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" }) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.maybe_toplevel_parser",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.not_reading"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out | false | true | Z3TestGen.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 parse_all_bytes:parser not_reading | [] | Z3TestGen.parse_all_bytes | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 69,
"end_line": 399,
"start_col": 2,
"start_line": 399
} |
Prims.Tot | val parse_all_zeros:parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" }) | val parse_all_zeros:parser not_reading
let parse_all_zeros:parser not_reading = | false | null | false | maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" }) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.maybe_toplevel_parser",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.not_reading"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" }) | false | true | Z3TestGen.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 parse_all_zeros:parser not_reading | [] | Z3TestGen.parse_all_zeros | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 69,
"end_line": 402,
"start_col": 2,
"start_line": 402
} |
Prims.Tot | val parse_denoted (d: I.dtyp) : parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d | val parse_denoted (d: I.dtyp) : parser not_reading
let parse_denoted (d: I.dtyp) : parser not_reading = | false | null | false | parse_dtyp d | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"InterpreterTarget.dtyp",
"Z3TestGen.parse_dtyp",
"Z3TestGen.parser",
"Z3TestGen.not_reading"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" }) | false | true | Z3TestGen.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 parse_denoted (d: I.dtyp) : parser not_reading | [] | Z3TestGen.parse_denoted | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | d: InterpreterTarget.dtyp -> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 14,
"end_line": 444,
"start_col": 2,
"start_line": 444
} |
Prims.Tot | val mk_parse_dep_pair_with_refinement
(name binders dfst cond_binder_name cond dsnd_binder_name dsnd: string)
: string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
" | val mk_parse_dep_pair_with_refinement
(name binders dfst cond_binder_name cond dsnd_binder_name dsnd: string)
: string
let mk_parse_dep_pair_with_refinement
(name binders dfst cond_binder_name cond dsnd_binder_name dsnd: string)
: string = | false | null | false | let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (let ((" ^
tmp ^
" (" ^
dfst ^
" " ^
input ^
")))\n (if (< (input-size (after-state " ^
tmp ^
")) 0)\n (after-state " ^
tmp ^
")\n (if (let ((" ^
cond_binder_name ^
" (return-value " ^
tmp ^
"))) " ^
cond ^
")\n (let ((" ^
dsnd_binder_name ^
" (return-value " ^
tmp ^
")))\n (" ^
dsnd ^
" (after-state " ^
tmp ^
"))\n )\n (mk-state -1 (choice-index (after-state " ^
tmp ^ ")))\n )\n )\n )\n )\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *) | false | true | Z3TestGen.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_parse_dep_pair_with_refinement
(name binders dfst cond_binder_name cond dsnd_binder_name dsnd: string)
: string | [] | Z3TestGen.mk_parse_dep_pair_with_refinement | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
name: Prims.string ->
binders: Prims.string ->
dfst: Prims.string ->
cond_binder_name: Prims.string ->
cond: Prims.string ->
dsnd_binder_name: Prims.string ->
dsnd: Prims.string
-> Prims.string | {
"end_col": 1,
"end_line": 504,
"start_col": 1,
"start_line": 489
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args | let mk_function_call (name: string) (b: binders) = | false | null | false | Printf.sprintf "%s%s" name b.args | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Z3TestGen.binders",
"FStar.Printf.sprintf",
"Z3TestGen.__proj__Mkbinders__item__args"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
} | false | true | Z3TestGen.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_function_call : name: Prims.string -> b: Z3TestGen.binders -> (Prims.string <: Type0) | [] | Z3TestGen.mk_function_call | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> b: Z3TestGen.binders -> (Prims.string <: Type0) | {
"end_col": 35,
"end_line": 327,
"start_col": 2,
"start_line": 327
} |
|
Prims.Tot | val parse_readable_app (hd: A.ident) (args: list I.expr) : Tot (parser reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args } | val parse_readable_app (hd: A.ident) (args: list I.expr) : Tot (parser reading)
let parse_readable_app (hd: A.ident) (args: list I.expr) : Tot (parser reading) = | false | null | false | fun _ _ _ _ -> { call = mk_app_without_paren hd args } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Ast.ident",
"Prims.list",
"InterpreterTarget.expr",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mkreading",
"Z3TestGen.reading",
"Z3TestGen.mk_app_without_paren",
"Z3TestGen.parser"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr) | false | true | Z3TestGen.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 parse_readable_app (hd: A.ident) (args: list I.expr) : Tot (parser reading) | [] | Z3TestGen.parse_readable_app | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | hd: Ast.ident -> args: Prims.list InterpreterTarget.expr -> Z3TestGen.parser Z3TestGen.reading | {
"end_col": 56,
"end_line": 416,
"start_col": 2,
"start_line": 416
} |
Prims.Tot | val parse_square (p: parser not_reading) : parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders } | val parse_square (p: parser not_reading) : parser not_reading
let parse_square (p: parser not_reading) : parser not_reading = | false | null | false | fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_pair",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders } | false | true | Z3TestGen.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 parse_square (p: parser not_reading) : parser not_reading | [] | Z3TestGen.parse_square | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | p: Z3TestGen.parser Z3TestGen.not_reading -> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 44,
"end_line": 478,
"start_col": 2,
"start_line": 474
} |
Prims.Tot | val mk_parse_exact (name binders body size: string) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
" | val mk_parse_exact (name binders body size: string) : string
let mk_parse_exact (name binders body size: string) : string = | false | null | false | let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (let ((" ^
sz ^
" " ^
size ^
"))\n (if (< (input-size " ^
input ^
") " ^
sz ^
")\n (mk-state -1 (choice-index " ^
input ^
"))\n (let ((" ^
res ^
" (" ^
body ^
" (mk-state " ^
sz ^
" (choice-index " ^
input ^
")))))\n (mk-state\n (if (= (input-size " ^
res ^
") 0)\n (- (input-size " ^
input ^
") " ^
sz ^
")\n -1\n )\n (choice-index " ^
res ^ ")\n )\n )\n )\n )\n)\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string) | false | true | Z3TestGen.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_parse_exact (name binders body size: string) : string | [] | Z3TestGen.mk_parse_exact | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> binders: Prims.string -> body: Prims.string -> size: Prims.string
-> Prims.string | {
"end_col": 1,
"end_line": 575,
"start_col": 1,
"start_line": 556
} |
Prims.Tot | val parse_list (body: parser not_reading) : Tot (parser not_reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call } | val parse_list (body: parser not_reading) : Tot (parser not_reading)
let parse_list (body: parser not_reading) : Tot (parser not_reading) = | false | null | false | fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_parse_list",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf",
"Z3TestGen.mk_function_call"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading) | false | true | Z3TestGen.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 parse_list (body: parser not_reading) : Tot (parser not_reading) | [] | Z3TestGen.parse_list | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | body: Z3TestGen.parser Z3TestGen.not_reading -> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 23,
"end_line": 663,
"start_col": 2,
"start_line": 658
} |
Prims.Tot | val parse_exact (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders } | val parse_exact (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading)
let parse_exact (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) = | false | null | false | fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.unit",
"Prims.string",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Z3TestGen.binders",
"Prims.bool",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_exact",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading) | false | false | Z3TestGen.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 parse_exact (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | [] | Z3TestGen.parse_exact | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | size: (_: Prims.unit -> FStar.All.ML Prims.string) -> body: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 44,
"end_line": 585,
"start_col": 2,
"start_line": 581
} |
Prims.Tot | val parse_nlist (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body) | val parse_nlist (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading)
let parse_nlist (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) = | false | null | false | parse_exact size (parse_list body) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.unit",
"Prims.string",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Z3TestGen.parse_exact",
"Z3TestGen.parse_list"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading) | false | false | Z3TestGen.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 parse_nlist (size: (unit -> ML string)) (body: parser not_reading) : Tot (parser not_reading) | [] | Z3TestGen.parse_nlist | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | size: (_: Prims.unit -> FStar.All.ML Prims.string) -> body: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 36,
"end_line": 669,
"start_col": 2,
"start_line": 669
} |
Prims.Tot | val parse_false:parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" }) | val parse_false:parser not_reading
let parse_false:parser not_reading = | false | null | false | maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" }) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Z3TestGen.maybe_toplevel_parser",
"Prims.string",
"Z3TestGen.binders",
"Prims.bool",
"Prims.unit",
"Z3TestGen.Mknot_reading",
"Z3TestGen.not_reading"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args | false | true | Z3TestGen.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 parse_false:parser not_reading | [] | Z3TestGen.parse_false | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 65,
"end_line": 441,
"start_col": 2,
"start_line": 441
} |
Prims.Tot | val parse_ifthenelse (cond: (unit -> ML string)) (pthen pelse: parser not_reading)
: parser not_reading | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders } | val parse_ifthenelse (cond: (unit -> ML string)) (pthen pelse: parser not_reading)
: parser not_reading
let parse_ifthenelse (cond: (unit -> ML string)) (pthen pelse: parser not_reading)
: parser not_reading = | false | null | false | fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders } | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.unit",
"Prims.string",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Z3TestGen.binders",
"Prims.bool",
"Z3TestGen.Mknot_reading",
"Z3TestGen.mk_function_call",
"Z3TestGen.mk_parse_ifthenelse",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.__proj__Mknot_reading__item__call",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
" | false | false | Z3TestGen.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 parse_ifthenelse (cond: (unit -> ML string)) (pthen pelse: parser not_reading)
: parser not_reading | [] | Z3TestGen.parse_ifthenelse | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cond: (_: Prims.unit -> FStar.All.ML Prims.string) ->
pthen: Z3TestGen.parser Z3TestGen.not_reading ->
pelse: Z3TestGen.parser Z3TestGen.not_reading
-> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 44,
"end_line": 548,
"start_col": 2,
"start_line": 542
} |
Prims.Tot | val mk_parse_string (name rec_call binders body terminator: string) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
" | val mk_parse_string (name rec_call binders body terminator: string) : string
let mk_parse_string (name rec_call binders body terminator: string) : string = | false | null | false | let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec " ^
name ^
" (" ^
binders ^
"(" ^
input ^
" State)) State\n (let ((" ^
tmp ^
" (" ^
body ^
" " ^
input ^
")))\n (if (< (choice-index (after-state " ^
tmp ^
")) 0)\n (mk-state -1 (choice-index (after-state " ^
tmp ^
")))\n (if (= (return-value " ^
tmp ^
") " ^
terminator ^
")\n (after-state " ^
tmp ^ ")\n (" ^ rec_call ^ " (after-state " ^ tmp ^ "))\n )\n )\n )\n)\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.op_Hat",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string) | false | true | Z3TestGen.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_parse_string (name rec_call binders body terminator: string) : string | [] | Z3TestGen.mk_parse_string | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
name: Prims.string ->
rec_call: Prims.string ->
binders: Prims.string ->
body: Prims.string ->
terminator: Prims.string
-> Prims.string | {
"end_col": 1,
"end_line": 691,
"start_col": 1,
"start_line": 678
} |
FStar.All.ML | val produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: (string -> ML unit))
: ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body)) | val produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: (string -> ML unit))
: ML unit
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: (string -> ML unit))
: ML unit = | true | null | false | let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body)) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Ast.ident",
"Prims.list",
"Target.param",
"Target.typ",
"Target.expr",
"Prims.string",
"Prims.unit",
"Z3TestGen.mk_definition",
"Z3TestGen.ident_to_string",
"Z3TestGen.__proj__Mkbinders__item__bind",
"Z3TestGen.smt_type_of_typ",
"Z3TestGen.mk_expr",
"Z3TestGen.binders",
"Z3TestGen.binders_of_params"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit) | false | false | Z3TestGen.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 produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: (string -> ML unit))
: ML unit | [] | Z3TestGen.produce_definition | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
i: Ast.ident ->
param: Prims.list Target.param ->
typ: Target.typ ->
body: Target.expr ->
out: (_: Prims.string -> FStar.All.ML Prims.unit)
-> FStar.All.ML Prims.unit | {
"end_col": 91,
"end_line": 791,
"start_col": 1,
"start_line": 790
} |
FStar.All.ML | val read_witness (z3: Z3.z3) : ML (Seq.seq int) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size | val read_witness (z3: Z3.z3) : ML (Seq.seq int)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) = | true | null | false | z3.to_z3 "(get-value (state-witness-size))\n";
let _, witness_size = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Z3.Base.z3",
"Prims.string",
"Prims.int",
"FStar.Seq.Base.empty",
"FStar.Seq.Base.seq",
"Prims.op_LessThanOrEqual",
"Prims.bool",
"FStar.Seq.Properties.cons",
"Lisp.read_bare_int_from",
"Z3.Base.__proj__Mkz3__item__from_z3",
"Prims.unit",
"Z3.Base.__proj__Mkz3__item__to_z3",
"FStar.Printf.sprintf",
"Prims.op_Subtraction",
"FStar.Pervasives.Native.tuple2",
"Lisp.read_int_from"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *) | false | false | Z3TestGen.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_witness (z3: Z3.z3) : ML (Seq.seq int) | [] | Z3TestGen.read_witness | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | z3: Z3.Base.z3 -> FStar.All.ML (FStar.Seq.Base.seq Prims.int) | {
"end_col": 28,
"end_line": 855,
"start_col": 2,
"start_line": 844
} |
FStar.All.ML | val module_and_wrapper_name (s: string) : ML (string & string) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name" | val module_and_wrapper_name (s: string) : ML (string & string)
let module_and_wrapper_name (s: string) : ML (string & string) = | false | null | false | match String.split ['.'] s with
| [modul ; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"FStar.String.split",
"Prims.Cons",
"FStar.String.char",
"Prims.Nil",
"FStar.Pervasives.Native.Mktuple2",
"FStar.Pervasives.Native.tuple2",
"Target.wrapper_name",
"Prims.list",
"FStar.All.failwith"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string) | false | false | Z3TestGen.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 module_and_wrapper_name (s: string) : ML (string & string) | [] | Z3TestGen.module_and_wrapper_name | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | s: Prims.string -> FStar.All.ML (Prims.string * Prims.string) | {
"end_col": 42,
"end_line": 872,
"start_col": 2,
"start_line": 870
} |
Prims.Tot | val parse_readable_dtyp (d: I.readable_dtyp) : Tot (parser reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args | val parse_readable_dtyp (d: I.readable_dtyp) : Tot (parser reading)
let parse_readable_dtyp (d: I.readable_dtyp) : Tot (parser reading) = | false | null | false | match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"InterpreterTarget.readable_dtyp",
"InterpreterTarget.itype",
"Z3TestGen.parse_readable_itype",
"Prims.bool",
"Ast.ident",
"Prims.list",
"InterpreterTarget.expr",
"Z3TestGen.parse_readable_app",
"Z3TestGen.parser",
"Z3TestGen.reading"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp) | false | true | Z3TestGen.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 parse_readable_dtyp (d: I.readable_dtyp) : Tot (parser reading) | [] | Z3TestGen.parse_readable_dtyp | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | d: InterpreterTarget.readable_dtyp -> Z3TestGen.parser Z3TestGen.reading | {
"end_col": 52,
"end_line": 423,
"start_col": 2,
"start_line": 421
} |
Prims.Tot | val mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg | val mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string = | false | null | false | match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"FStar.Pervasives.Native.option",
"Ast.integer_type",
"Prims.string",
"Z3TestGen.mk_bitwise_arg"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg) | false | true | Z3TestGen.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_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string | [] | Z3TestGen.mk_maybe_bitwise_arg | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: FStar.Pervasives.Native.option Ast.integer_type -> arg: Prims.string -> Prims.string | {
"end_col": 34,
"end_line": 289,
"start_col": 2,
"start_line": 287
} |
FStar.All.ML | val print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int{len == Seq.length witness} -> ML unit))
: ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
" | val print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int{len == Seq.length witness} -> ML unit))
: ML unit
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int{len == Seq.length witness} -> ML unit))
: ML unit = | true | null | false | let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "\n printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");\n";
f len;
out "};\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.unit",
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.eq2",
"FStar.Seq.Base.length",
"Z3TestGen.print_witness_as_c_aux",
"Prims.nat"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit) | false | false | Z3TestGen.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 print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int{len == Seq.length witness} -> ML unit))
: ML unit | [] | Z3TestGen.print_witness_as_c_gen | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
witness: FStar.Seq.Base.seq Prims.int ->
f: (len: Prims.int{len == FStar.Seq.Base.length witness} -> FStar.All.ML Prims.unit)
-> FStar.All.ML Prims.unit | {
"end_col": 1,
"end_line": 961,
"start_col": 1,
"start_line": 951
} |
FStar.All.ML | val print_witness (witness: Seq.seq int) : ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n" | val print_witness (witness: Seq.seq int) : ML unit
let print_witness (witness: Seq.seq int) : ML unit = | true | null | false | FStar.IO.print_string " produced witness: [";
List.iter (fun i ->
FStar.IO.print_string (string_of_int i);
FStar.IO.print_string "; ")
(Seq.seq_to_list witness);
FStar.IO.print_string "]\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"FStar.Seq.Base.seq",
"Prims.int",
"FStar.IO.print_string",
"Prims.unit",
"FStar.List.iter",
"Prims.string_of_int",
"FStar.Seq.Properties.seq_to_list"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
) | false | false | Z3TestGen.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 print_witness (witness: Seq.seq int) : ML unit | [] | Z3TestGen.print_witness | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | witness: FStar.Seq.Base.seq Prims.int -> FStar.All.ML Prims.unit | {
"end_col": 29,
"end_line": 991,
"start_col": 2,
"start_line": 989
} |
Prims.Tot | val mk_get_first_positive_test_witness (name: string) (l: list arg_type) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_get_first_positive_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^ "
(assert (>= state-witness-input-size 0))
" | val mk_get_first_positive_test_witness (name: string) (l: list arg_type) : string
let mk_get_first_positive_test_witness (name: string) (l: list arg_type) : string = | false | null | false | mk_get_witness name l ^ "\n(assert (>= state-witness-input-size 0))\n" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.op_Hat",
"Z3TestGen.mk_get_witness"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n"
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l) | false | false | Z3TestGen.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_get_first_positive_test_witness (name: string) (l: list arg_type) : string | [] | Z3TestGen.mk_get_first_positive_test_witness | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> l: Prims.list Z3TestGen.arg_type -> Prims.string | {
"end_col": 1,
"end_line": 1071,
"start_col": 2,
"start_line": 1069
} |
FStar.All.ML | val mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))" | val mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string = | true | null | false | match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor " ^ arg ^ " #b" ^ String.make (integer_type_bit_size a) '1' ^ "))" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Ast.integer_type",
"FStar.Pervasives.Native.option",
"Prims.string",
"FStar.All.failwith",
"Prims.op_Hat",
"FStar.String.make",
"Z3TestGen.integer_type_bit_size"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64 | false | false | Z3TestGen.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_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string | [] | Z3TestGen.mk_bitwise_not | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | a: Ast.integer_type -> bitvec_arg: FStar.Pervasives.Native.option Prims.string
-> FStar.All.ML Prims.string | {
"end_col": 90,
"end_line": 253,
"start_col": 2,
"start_line": 251
} |
Prims.Tot | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64 | let integer_type_bit_size = | false | null | false | function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64 | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Ast.integer_type",
"Prims.int"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args)) | false | true | Z3TestGen.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 integer_type_bit_size : _: Ast.integer_type -> Prims.int | [] | Z3TestGen.integer_type_bit_size | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | _: Ast.integer_type -> Prims.int | {
"end_col": 16,
"end_line": 248,
"start_col": 28,
"start_line": 244
} |
|
Prims.Tot | val mk_get_first_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_get_first_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string =
Printf.sprintf
"
%s
(assert (< (input-size (%s initial-state)) 0))
"
(mk_get_first_positive_test_witness name1 l)
(mk_call_args name2 0 l) | val mk_get_first_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string
let mk_get_first_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string = | false | null | false | Printf.sprintf "\n%s\n(assert (< (input-size (%s initial-state)) 0))\n"
(mk_get_first_positive_test_witness name1 l)
(mk_call_args name2 0 l) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Printf.sprintf",
"Z3TestGen.mk_get_first_positive_test_witness",
"Z3TestGen.mk_call_args"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n"
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
let mk_get_first_positive_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^ "
(assert (>= state-witness-input-size 0))
"
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let mk_get_first_negative_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^
"
(assert (< state-witness-input-size 0))
"
let do_test (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (pos: bool) (neg: bool) : ML unit =
let args = List.assoc name1 prog in
if None? args
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = Some?.v args in
let modul, wrapper_name = module_and_wrapper_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include \"";
cout modul;
cout "Wrapper.h\"
int main(void) {
";
if pos
then begin
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
witnesses_for (print_witness_as_c cout true wrapper_name args) z3 name1 args nargs (mk_get_first_positive_test_witness name1 args) mk_want_another_distinct_witness nbwitnesses
end;
if neg
then begin
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
witnesses_for (print_witness_as_c cout false wrapper_name args) z3 name1 args nargs (mk_get_first_negative_test_witness name1 args) mk_want_another_distinct_witness nbwitnesses
end;
cout " return 0;
}
"
) | false | false | Z3TestGen.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_get_first_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string | [] | Z3TestGen.mk_get_first_diff_test_witness | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name1: Prims.string -> l: Prims.list Z3TestGen.arg_type -> name2: Prims.string -> Prims.string | {
"end_col": 26,
"end_line": 1132,
"start_col": 2,
"start_line": 1126
} |
Prims.Tot | val parse_dtyp (d: I.dtyp) : Tot (parser not_reading) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args | val parse_dtyp (d: I.dtyp) : Tot (parser not_reading)
let parse_dtyp (d: I.dtyp) : Tot (parser not_reading) = | false | null | false | if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else
match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"InterpreterTarget.dtyp",
"InterpreterTarget.allow_reader_of_dtyp",
"Z3TestGen.wrap_parser",
"Z3TestGen.parse_readable_dtyp",
"Prims.bool",
"InterpreterTarget.itype",
"Z3TestGen.parse_itype",
"Ast.ident",
"Prims.list",
"InterpreterTarget.expr",
"Z3TestGen.parse_not_readable_app",
"Z3TestGen.parser",
"Z3TestGen.not_reading"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp) | false | true | Z3TestGen.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 parse_dtyp (d: I.dtyp) : Tot (parser not_reading) | [] | Z3TestGen.parse_dtyp | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | d: InterpreterTarget.dtyp -> Z3TestGen.parser Z3TestGen.not_reading | {
"end_col": 58,
"end_line": 438,
"start_col": 2,
"start_line": 434
} |
FStar.All.ML | val print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int{len == Seq.length witness})
: ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};" | val print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int{len == Seq.length witness})
: ML unit
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int{len == Seq.length witness})
: ML unit = | true | null | false | out " uint8_t witness[";
out (string_of_int len);
out "] = {";
(match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i ->
out ", ";
out (string_of_int i))
q);
out "};" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.unit",
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.eq2",
"FStar.Seq.Base.length",
"FStar.Seq.Properties.seq_to_list",
"Prims.list",
"FStar.List.iter",
"Prims.string_of_int"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit | false | false | Z3TestGen.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 print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int{len == Seq.length witness})
: ML unit | [] | Z3TestGen.print_witness_as_c_aux | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
witness: FStar.Seq.Base.seq Prims.int ->
len: Prims.int{len == FStar.Seq.Base.length witness}
-> FStar.All.ML Prims.unit | {
"end_col": 10,
"end_line": 944,
"start_col": 2,
"start_line": 935
} |
FStar.All.ML | val print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1 wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
) | val print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1 wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1 wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit = | true | null | false | print_witness_as_c_gen out
witness
(fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Prims.string",
"Prims.unit",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Seq.Base.seq",
"Prims.int",
"Z3TestGen.print_witness_as_c_gen",
"Prims.eq2",
"FStar.Seq.Base.length",
"Z3TestGen.print_witness_call_as_c"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string) | false | false | Z3TestGen.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 print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1 wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit | [] | Z3TestGen.print_diff_witness_as_c | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
out: (_: Prims.string -> FStar.All.ML Prims.unit) ->
wrapper_name1: Prims.string ->
wrapper_name2: Prims.string ->
arg_types: Prims.list Z3TestGen.arg_type ->
witness: FStar.Seq.Base.seq Prims.int ->
args: Prims.list Prims.string
-> FStar.All.ML Prims.unit | {
"end_col": 3,
"end_line": 986,
"start_col": 2,
"start_line": 983
} |
FStar.All.ALL | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let do_diff_test_for (cout: string -> ML unit) (z3: Z3.z3) (prog: prog) name1 name2 args (nargs: nat { nargs == count_args args }) wrapper_name1 wrapper_name2 nbwitnesses =
FStar.IO.print_string (Printf.sprintf ";; Witnesses that work with %s but not with %s\n" name1 name2);
witnesses_for (print_diff_witness_as_c cout wrapper_name1 wrapper_name2 args) z3 name1 args nargs (mk_get_first_diff_test_witness name1 args name2) mk_want_another_distinct_witness nbwitnesses | let do_diff_test_for
(cout: (string -> ML unit))
(z3: Z3.z3)
(prog: prog)
name1
name2
args
(nargs: nat{nargs == count_args args})
wrapper_name1
wrapper_name2
nbwitnesses
= | true | null | false | FStar.IO.print_string (Printf.sprintf ";; Witnesses that work with %s but not with %s\n" name1 name2
);
witnesses_for (print_diff_witness_as_c cout wrapper_name1 wrapper_name2 args)
z3
name1
args
nargs
(mk_get_first_diff_test_witness name1 args name2)
mk_want_another_distinct_witness
nbwitnesses | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [] | [
"Prims.string",
"Prims.unit",
"Z3.Base.z3",
"Z3TestGen.prog",
"Prims.list",
"Z3TestGen.arg_type",
"Prims.nat",
"Prims.eq2",
"Z3TestGen.count_args",
"Prims.int",
"Z3TestGen.witnesses_for",
"Z3TestGen.print_diff_witness_as_c",
"Z3TestGen.mk_get_first_diff_test_witness",
"Z3TestGen.mk_want_another_distinct_witness",
"FStar.IO.print_string",
"FStar.Printf.sprintf"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n"
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
let mk_get_first_positive_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^ "
(assert (>= state-witness-input-size 0))
"
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let mk_get_first_negative_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^
"
(assert (< state-witness-input-size 0))
"
let do_test (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (pos: bool) (neg: bool) : ML unit =
let args = List.assoc name1 prog in
if None? args
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = Some?.v args in
let modul, wrapper_name = module_and_wrapper_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include \"";
cout modul;
cout "Wrapper.h\"
int main(void) {
";
if pos
then begin
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
witnesses_for (print_witness_as_c cout true wrapper_name args) z3 name1 args nargs (mk_get_first_positive_test_witness name1 args) mk_want_another_distinct_witness nbwitnesses
end;
if neg
then begin
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
witnesses_for (print_witness_as_c cout false wrapper_name args) z3 name1 args nargs (mk_get_first_negative_test_witness name1 args) mk_want_another_distinct_witness nbwitnesses
end;
cout " return 0;
}
"
)
let mk_get_first_diff_test_witness (name1: string) (l: list arg_type) (name2: string) : string =
Printf.sprintf
"
%s
(assert (< (input-size (%s initial-state)) 0))
"
(mk_get_first_positive_test_witness name1 l)
(mk_call_args name2 0 l) | false | false | Z3TestGen.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 do_diff_test_for : cout: (_: Prims.string -> FStar.All.ML Prims.unit) ->
z3: Z3.Base.z3 ->
prog: Z3TestGen.prog ->
name1: Prims.string ->
name2: Prims.string ->
args: Prims.list Z3TestGen.arg_type ->
nargs: Prims.nat{nargs == Z3TestGen.count_args args} ->
wrapper_name1: Prims.string ->
wrapper_name2: Prims.string ->
nbwitnesses: Prims.int
-> FStar.All.ALL Prims.unit | [] | Z3TestGen.do_diff_test_for | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
cout: (_: Prims.string -> FStar.All.ML Prims.unit) ->
z3: Z3.Base.z3 ->
prog: Z3TestGen.prog ->
name1: Prims.string ->
name2: Prims.string ->
args: Prims.list Z3TestGen.arg_type ->
nargs: Prims.nat{nargs == Z3TestGen.count_args args} ->
wrapper_name1: Prims.string ->
wrapper_name2: Prims.string ->
nbwitnesses: Prims.int
-> FStar.All.ALL Prims.unit | {
"end_col": 194,
"end_line": 1136,
"start_col": 2,
"start_line": 1135
} |
|
Prims.Tot | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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 binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q) | let rec binders_of_params = | false | null | false | function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.list",
"FStar.Pervasives.Native.tuple2",
"Ast.with_meta_t",
"Ast.ident'",
"Target.typ",
"Z3TestGen.empty_binders",
"Z3TestGen.push_binder",
"Z3TestGen.ident_to_string",
"Z3TestGen.smt_type_of_typ",
"Z3TestGen.binders_of_params",
"Z3TestGen.binders"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int" | false | true | Z3TestGen.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 binders_of_params : _: Prims.list (Ast.with_meta_t Ast.ident' * Target.typ) -> Z3TestGen.binders | [
"recursion"
] | Z3TestGen.binders_of_params | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | _: Prims.list (Ast.with_meta_t Ast.ident' * Target.typ) -> Z3TestGen.binders | {
"end_col": 92,
"end_line": 773,
"start_col": 28,
"start_line": 771
} |
|
Prims.Tot | val mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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 mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu | val mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l)
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string)
: Tot string (decreases l) = | false | null | false | match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total",
""
] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Pervasives.Native.Mktuple2",
"Z3TestGen.mk_witness_call",
"FStar.Printf.sprintf",
"FStar.Pervasives.Native.tuple2"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n" | false | true | Z3TestGen.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_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) | [
"recursion"
] | Z3TestGen.mk_witness_call | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | accu: Prims.string -> l: Prims.list Z3TestGen.arg_type -> args: Prims.list Prims.string
-> Prims.Tot Prims.string | {
"end_col": 35,
"end_line": 997,
"start_col": 2,
"start_line": 994
} |
FStar.All.ML | val read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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 read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end | val read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string)
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) = | true | null | false | if n = 0
then accu
else
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n' | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"Z3.Base.z3",
"Prims.list",
"Prims.string",
"Prims.nat",
"Prims.op_Equality",
"Prims.int",
"Prims.bool",
"Z3TestGen.read_witness_args",
"Prims.Cons",
"Lisp.read_any_from",
"Z3.Base.__proj__Mkz3__item__from_z3",
"FStar.Printf.sprintf",
"Prims.unit",
"Z3.Base.__proj__Mkz3__item__to_z3",
"Prims.op_Subtraction"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size | false | false | Z3TestGen.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_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) | [
"recursion"
] | Z3TestGen.read_witness_args | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | z3: Z3.Base.z3 -> accu: Prims.list Prims.string -> n: Prims.nat
-> FStar.All.ML (Prims.list Prims.string) | {
"end_col": 5,
"end_line": 865,
"start_col": 2,
"start_line": 858
} |
Prims.Tot | val mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat)
: Tot string (decreases (if i >= Seq.length witness then 0 else Seq.length witness - i)) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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 mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1) | val mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat)
: Tot string (decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat)
: Tot string (decreases (if i >= Seq.length witness then 0 else Seq.length witness - i)) = | false | null | false | if i >= Seq.length witness
then accu
else
mk_choose_conj witness
("(and (= (choose " ^
string_of_int i ^ ") " ^ string_of_int (Seq.index witness i) ^ ") " ^ accu ^ ")")
(i + 1) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total",
""
] | [
"FStar.Seq.Base.seq",
"Prims.int",
"Prims.string",
"Prims.nat",
"Prims.op_GreaterThanOrEqual",
"FStar.Seq.Base.length",
"Prims.bool",
"Z3TestGen.mk_choose_conj",
"Prims.op_Hat",
"Prims.string_of_int",
"FStar.Seq.Base.index",
"Prims.op_Addition"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n"
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
let mk_get_first_positive_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^ "
(assert (>= state-witness-input-size 0))
"
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string | false | true | Z3TestGen.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_choose_conj (witness: Seq.seq int) (accu: string) (i: nat)
: Tot string (decreases (if i >= Seq.length witness then 0 else Seq.length witness - i)) | [
"recursion"
] | Z3TestGen.mk_choose_conj | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | witness: FStar.Seq.Base.seq Prims.int -> accu: Prims.string -> i: Prims.nat
-> Prims.Tot Prims.string | {
"end_col": 129,
"end_line": 1077,
"start_col": 2,
"start_line": 1075
} |
Prims.Tot | val mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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 mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q | val mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l)
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) = | false | null | false | match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total",
""
] | [
"Prims.string",
"Prims.nat",
"Prims.list",
"Z3TestGen.arg_type",
"Z3TestGen.mk_call_args",
"FStar.Printf.sprintf",
"Prims.op_Addition"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n" | false | true | Z3TestGen.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_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) | [
"recursion"
] | Z3TestGen.mk_call_args | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | accu: Prims.string -> i: Prims.nat -> l: Prims.list Z3TestGen.arg_type -> Prims.Tot Prims.string | {
"end_col": 72,
"end_line": 1047,
"start_col": 2,
"start_line": 1044
} |
Prims.Tot | val mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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 mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q | val mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l)
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) = | false | null | false | match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q ->
mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q ->
mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n"
accu
i
i
i
(pow2 (integer_type_bit_size it)))
(i + 1)
q | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total",
""
] | [
"Prims.string",
"Prims.nat",
"Prims.list",
"Z3TestGen.arg_type",
"Z3TestGen.mk_assert_args",
"FStar.Printf.sprintf",
"Prims.op_Addition",
"Ast.integer_type",
"Prims.pow2",
"Z3TestGen.integer_type_bit_size"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n"
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q | false | true | Z3TestGen.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_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) | [
"recursion"
] | Z3TestGen.mk_assert_args | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | accu: Prims.string -> i: Prims.nat -> l: Prims.list Z3TestGen.arg_type -> Prims.Tot Prims.string | {
"end_col": 186,
"end_line": 1054,
"start_col": 2,
"start_line": 1050
} |
FStar.All.ML | val produce_not_type_decl (a: I.not_type_decl) (out: (string -> ML unit)) : ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> () | val produce_not_type_decl (a: I.not_type_decl) (out: (string -> ML unit)) : ML unit
let produce_not_type_decl (a: I.not_type_decl) (out: (string -> ML unit)) : ML unit = | true | null | false | match fst a with
| T.Definition (i, param, typ, body) -> produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _ | T.Output_type_expr _ _ | T.Extern_type _ | T.Extern_fn _ _ _ -> () | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"InterpreterTarget.not_type_decl",
"Prims.string",
"Prims.unit",
"FStar.Pervasives.Native.fst",
"Target.decl'",
"Target.decl_attributes",
"Ast.ident",
"Prims.list",
"Target.param",
"Target.typ",
"Target.expr",
"Z3TestGen.produce_definition",
"Target.assumption",
"FStar.All.failwith",
"Ast.out_typ",
"Target.output_expr",
"Prims.bool"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body)) | false | false | Z3TestGen.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 produce_not_type_decl (a: I.not_type_decl) (out: (string -> ML unit)) : ML unit | [] | Z3TestGen.produce_not_type_decl | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | a: InterpreterTarget.not_type_decl -> out: (_: Prims.string -> FStar.All.ML Prims.unit)
-> FStar.All.ML Prims.unit | {
"end_col": 7,
"end_line": 802,
"start_col": 2,
"start_line": 794
} |
FStar.All.ML | val do_test
(out_file: option string)
(z3: Z3.z3)
(prog: prog)
(name1: string)
(nbwitnesses: int)
(pos neg: bool)
: ML unit | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_module": "FStar.Pervasives",
"short_module": null
},
{
"abbrev": false,
"full_module": "Prims",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar",
"short_module": null
}
] | false | let do_test (out_file: option string) (z3: Z3.z3) (prog: prog) (name1: string) (nbwitnesses: int) (pos: bool) (neg: bool) : ML unit =
let args = List.assoc name1 prog in
if None? args
then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = Some?.v args in
let modul, wrapper_name = module_and_wrapper_name name1 in
let nargs = count_args args in with_option_out_file out_file (fun cout ->
cout "#include <stdio.h>
#include \"";
cout modul;
cout "Wrapper.h\"
int main(void) {
";
if pos
then begin
FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
witnesses_for (print_witness_as_c cout true wrapper_name args) z3 name1 args nargs (mk_get_first_positive_test_witness name1 args) mk_want_another_distinct_witness nbwitnesses
end;
if neg
then begin
FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
witnesses_for (print_witness_as_c cout false wrapper_name args) z3 name1 args nargs (mk_get_first_negative_test_witness name1 args) mk_want_another_distinct_witness nbwitnesses
end;
cout " return 0;
}
"
) | val do_test
(out_file: option string)
(z3: Z3.z3)
(prog: prog)
(name1: string)
(nbwitnesses: int)
(pos neg: bool)
: ML unit
let do_test
(out_file: option string)
(z3: Z3.z3)
(prog: prog)
(name1: string)
(nbwitnesses: int)
(pos neg: bool)
: ML unit = | true | null | false | let args = List.assoc name1 prog in
if None? args then failwith (Printf.sprintf "do_test: parser %s not found" name1);
let args = Some?.v args in
let modul, wrapper_name = module_and_wrapper_name name1 in
let nargs = count_args args in
with_option_out_file out_file
(fun cout ->
cout "#include <stdio.h>\n#include \"";
cout modul;
cout "Wrapper.h\"\n int main(void) {\n";
if pos
then
(FStar.IO.print_string (Printf.sprintf ";; Positive test witnesses for %s\n" name1);
witnesses_for (print_witness_as_c cout true wrapper_name args)
z3
name1
args
nargs
(mk_get_first_positive_test_witness name1 args)
mk_want_another_distinct_witness
nbwitnesses);
if neg
then
(FStar.IO.print_string (Printf.sprintf ";; Negative test witnesses for %s\n" name1);
witnesses_for (print_witness_as_c cout false wrapper_name args)
z3
name1
args
nargs
(mk_get_first_negative_test_witness name1 args)
mk_want_another_distinct_witness
nbwitnesses);
cout " return 0;\n }\n") | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"ml"
] | [
"FStar.Pervasives.Native.option",
"Prims.string",
"Z3.Base.z3",
"Z3TestGen.prog",
"Prims.int",
"Prims.bool",
"Z3TestGen.with_option_out_file",
"Prims.unit",
"Z3TestGen.witnesses_for",
"Z3TestGen.print_witness_as_c",
"Z3TestGen.mk_get_first_negative_test_witness",
"Z3TestGen.mk_want_another_distinct_witness",
"FStar.IO.print_string",
"FStar.Printf.sprintf",
"Z3TestGen.mk_get_first_positive_test_witness",
"Prims.nat",
"Z3TestGen.count_args",
"FStar.Pervasives.Native.tuple2",
"Z3TestGen.module_and_wrapper_name",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Pervasives.Native.__proj__Some__item__v",
"FStar.Pervasives.Native.uu___is_None",
"FStar.All.failwith",
"FStar.List.Tot.Base.assoc"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n"
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q
let mk_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l)
let mk_get_first_positive_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^ "
(assert (>= state-witness-input-size 0))
"
let rec mk_choose_conj (witness: Seq.seq int) (accu: string) (i: nat) : Tot string
(decreases (if i >= Seq.length witness then 0 else Seq.length witness - i))
= if i >= Seq.length witness
then accu
else mk_choose_conj witness ("(and (= (choose "^string_of_int i^") "^string_of_int (Seq.index witness i)^") "^accu^")") (i + 1)
let rec mk_arg_conj (accu: string) (i: nat) (l: list string) : Tot string (decreases l) =
match l with
| [] -> accu
| arg :: q ->
mk_arg_conj (Printf.sprintf "(and %s (= arg-%d %s))" accu i arg) (i + 1) q
let mk_want_another_distinct_witness witness witness_args : Tot string =
Printf.sprintf
"(assert (not %s))
"
(mk_arg_conj (mk_choose_conj witness ("(= (choice-index state-witness) "^string_of_int (Seq.length witness)^")") 0) 0 witness_args)
let mk_get_first_negative_test_witness (name: string) (l: list arg_type) : string =
mk_get_witness name l ^
"
(assert (< state-witness-input-size 0))
" | false | false | Z3TestGen.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 do_test
(out_file: option string)
(z3: Z3.z3)
(prog: prog)
(name1: string)
(nbwitnesses: int)
(pos neg: bool)
: ML unit | [] | Z3TestGen.do_test | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} |
out_file: FStar.Pervasives.Native.option Prims.string ->
z3: Z3.Base.z3 ->
prog: Z3TestGen.prog ->
name1: Prims.string ->
nbwitnesses: Prims.int ->
pos: Prims.bool ->
neg: Prims.bool
-> FStar.All.ML Prims.unit | {
"end_col": 3,
"end_line": 1123,
"start_col": 133,
"start_line": 1097
} |
Prims.Tot | val mk_get_witness (name: string) (l: list arg_type) : string | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_get_witness (name: string) (l: list arg_type) : string =
Printf.sprintf "
%s
(define-fun state-witness () State (%s initial-state))
(define-fun state-witness-input-size () Int (input-size state-witness))
(declare-fun state-witness-size () Int)
(assert (<= state-witness-size (choice-index state-witness)))
(assert (>= state-witness-size (choice-index state-witness)))
"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l) | val mk_get_witness (name: string) (l: list arg_type) : string
let mk_get_witness (name: string) (l: list arg_type) : string = | false | null | false | Printf.sprintf "\n%s\n(define-fun state-witness () State (%s initial-state))\n(define-fun state-witness-input-size () Int (input-size state-witness))\n(declare-fun state-witness-size () Int)\n(assert (<= state-witness-size (choice-index state-witness)))\n(assert (>= state-witness-size (choice-index state-witness)))\n"
(mk_assert_args "" 0 l)
(mk_call_args name 0 l) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [
"total"
] | [
"Prims.string",
"Prims.list",
"Z3TestGen.arg_type",
"FStar.Printf.sprintf",
"Z3TestGen.mk_assert_args",
"Z3TestGen.mk_call_args"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body)
type arg_type =
| ArgInt of A.integer_type
| ArgBool
| ArgPointer
let arg_type_of_typ (t: T.typ) : Tot (option arg_type) =
match t with
| T.T_pointer _
| T.T_app _ A.KindOutput _
| T.T_app _ A.KindExtern _
| T.T_app {v = {modul_name = None; name = "PUINT8"}} _ _
-> Some ArgPointer
| T.T_app {v = {modul_name = None; name = "Bool"}} _ _
-> Some ArgBool
| T.T_app i _ _
->
begin match A.maybe_as_integer_typ i with
| Some t -> Some (ArgInt t)
| None -> None
end
| _ -> None
let smt_type_of_typ (t: T.typ) : Tot string =
match arg_type_of_typ t with
| Some ArgBool -> "Bool"
| _ -> "Int"
let rec binders_of_params = function
| [] -> empty_binders
| (id, t) :: q -> push_binder (ident_to_string id) (smt_type_of_typ t) (binders_of_params q)
let mk_definition
(name: string)
(binders: string)
(typ: string)
(body: string)
: Tot string
= "(define-fun "^name^" ("^binders^") "^typ^" "^body^")"
let produce_definition
(i: A.ident)
(param: list T.param)
(typ: T.typ)
(body: T.expr)
(out: string -> ML unit)
: ML unit
= let binders = binders_of_params param in
out (mk_definition (ident_to_string i) binders.bind (smt_type_of_typ typ) (mk_expr body))
let produce_not_type_decl (a: I.not_type_decl) (out: string -> ML unit) : ML unit =
match fst a with
| T.Definition (i, param, typ, body) ->
produce_definition i param typ body out
| T.Assumption _ -> failwith "produce_not_type_decl: unsupported"
| T.Output_type _
| T.Output_type_expr _ _
| T.Extern_type _
| T.Extern_fn _ _ _
-> ()
let prog = list (string & list arg_type)
let produce_type_decl (out: string -> ML unit) (accu: prog) (a: I.type_decl) : ML prog =
let binders = binders_of_params a.name.td_params in
let name = ident_to_string a.name.td_name in
if type_has_actions a.typ then failwith (Printf.sprintf "produce_type_decl: %s still has some actions" name);
let _ = parse_typ a.typ name binders true out in
(name, List.map (fun (i, ty) -> match arg_type_of_typ ty with Some t -> t | None -> failwith (Printf.sprintf "Parser %s has unsupported argument type for %s" name (ident_to_string i))) a.name.td_params) :: accu
let produce_decl (out: string -> ML unit) (accu: prog) (a: I.decl) : ML prog =
match a with
| Inl a -> produce_not_type_decl a out; accu
| Inr a -> produce_type_decl out accu a
let produce_decls (out: string -> ML unit) (accu: prog) (l: list I.decl) : ML prog =
List.fold_left (produce_decl out) accu l
(* Produce the SMT2 encoding of the parser spec *)
let with_out_file
(#a: Type)
(name: string)
(body: ((string -> ML unit) -> ML a))
: ML a
= let fd = FStar.IO.open_write_file name in
let res = body (FStar.IO.write_string fd) in
FStar.IO.close_write_file fd;
res
let with_option_out_file
(#a: Type)
(name: option string)
: Tot ((body: ((string -> ML unit) -> ML a)) -> ML a)
= match name with
| Some name -> with_out_file name
| None -> (fun body -> body (fun _ -> ()))
(* Ask Z3 for test witnesses *)
let read_witness (z3: Z3.z3) : ML (Seq.seq int) =
z3.to_z3 "(get-value (state-witness-size))\n";
let (_, witness_size) = Lisp.read_int_from z3.from_z3 "state-witness-size" in
let rec aux (accu: Seq.seq int) (remaining: int) : ML (Seq.seq int) =
if remaining <= 0
then accu
else
let index = remaining - 1 in
let _ = z3.to_z3 (Printf.sprintf "(eval (choose %d))\n" index) in
let v = Lisp.read_bare_int_from z3.from_z3 in
aux (Seq.cons v accu) index
in
aux Seq.empty witness_size
let rec read_witness_args (z3: Z3.z3) (accu: list string) (n: nat) : ML (list string) =
if n = 0
then accu
else begin
let n' = n - 1 in
z3.to_z3 (Printf.sprintf "(get-value (arg-%d))\n" n');
let arg = Lisp.read_any_from z3.from_z3 (Printf.sprintf "arg-%d" n') in
read_witness_args z3 (arg :: accu) n'
end
let module_and_wrapper_name
(s: string)
: ML (string & string)
= match String.split ['.'] s with
| [modul; fn] -> modul, Target.wrapper_name modul fn
| _ -> failwith "Z3TestGen.wrapper_name"
let rec print_witness_args_as_c
(out: (string -> ML unit))
(l: list arg_type) (args: list string)
: ML unit
= match l, args with
| ArgPointer :: q, _ ->
out "NULL, ";
print_witness_args_as_c out q args
| ty :: ql, a :: qargs ->
out a;
(if ArgInt? ty then out "U" else ());
out ", ";
print_witness_args_as_c out ql qargs
| _ -> ()
let print_witness_call_as_c_aux
(out: (string -> ML unit))
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out wrapper_name;
out "(";
print_witness_args_as_c out arg_types args;
out "witness, ";
out (string_of_int witness_length);
out ");"
let print_witness_call_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness_length: nat)
(args: list string)
: ML unit
=
out "
{
BOOLEAN result = ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out "
printf(\" ";
print_witness_call_as_c_aux out wrapper_name arg_types witness_length args;
out " // \");
if (result) printf (\"ACCEPTED\\n\\n\"); else printf (\"REJECTED\\n\\n\");
if (";
if positive then out "!";
out "result)
return 1;
};
"
let print_witness_as_c_aux
(out: (string -> ML unit))
(witness: Seq.seq int)
(len: int { len == Seq.length witness })
: ML unit
=
out " uint8_t witness[";
out (string_of_int len);
out "] = {";
begin match Seq.seq_to_list witness with
| [] -> ()
| a :: q ->
out (string_of_int a);
List.iter (fun i -> out ", "; out (string_of_int i)) q
end;
out "};"
let print_witness_as_c_gen
(out: (string -> ML unit))
(witness: Seq.seq int)
(f: (len: int { len == Seq.length witness }) -> ML unit)
: ML unit
= let len = Seq.length witness in
out "{\n";
print_witness_as_c_aux out witness len;
out "
printf(\"";
print_witness_as_c_aux out witness len;
out "\\n\");
";
f len;
out "};
"
let print_witness_as_c
(out: (string -> ML unit))
(positive: bool)
(wrapper_name: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out positive wrapper_name arg_types len args
)
let print_diff_witness_as_c
(out: (string -> ML unit))
(wrapper_name1: string)
(wrapper_name2: string)
(arg_types: list arg_type)
(witness: Seq.seq int)
(args: list string)
: ML unit
= print_witness_as_c_gen out witness (fun len ->
print_witness_call_as_c out true wrapper_name1 arg_types len args;
print_witness_call_as_c out false wrapper_name2 arg_types len args
)
let print_witness (witness: Seq.seq int) : ML unit =
FStar.IO.print_string " produced witness: [";
List.iter (fun i -> FStar.IO.print_string (string_of_int i); FStar.IO.print_string "; ") (Seq.seq_to_list witness);
FStar.IO.print_string "]\n"
let rec mk_witness_call (accu: string) (l: list arg_type) (args: list string) : Tot string (decreases l) =
match l, args with
| ArgPointer :: q, _ -> mk_witness_call (Printf.sprintf "%s 0" accu) q args
| _ :: ql, a :: qargs -> mk_witness_call (Printf.sprintf "%s %s" accu a) ql qargs
| _ -> Printf.sprintf "(%s)" accu
let print_witness_and_call (name: string) (l: list arg_type) (witness: Seq.seq int) (args: list string) : ML unit =
FStar.IO.print_string ";; call ";
FStar.IO.print_string (mk_witness_call name l args);
print_witness witness
let count_args (l: list arg_type) : Tot nat = List.Tot.length (List.Tot.filter (function ArgPointer -> false | _ -> true) l)
let rec want_witnesses (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) (mk_want_another_witness: Seq.seq int -> list string -> Tot string) i : ML unit =
z3.to_z3 "(check-sat)\n";
let status = z3.from_z3 () in
if status = "sat" then begin
let witness = read_witness z3 in
let witness_args = read_witness_args z3 [] nargs in
print_witness_and_call name l witness witness_args;
print_test_case witness witness_args;
if i <= 1
then ()
else begin
z3.to_z3 (mk_want_another_witness witness witness_args);
want_witnesses print_test_case z3 name l nargs mk_want_another_witness (i - 1)
end
end
else begin
FStar.IO.print_string
begin
if status = "unsat"
then";; unsat: no more witnesses"
else if status = "unknown"
then begin
z3.to_z3 "(get-info :reason-unknown)";
let msg = z3.from_z3 () in
Printf.sprintf ";; unknown: %s" msg
end
else Printf.sprintf ";; %s: z3 gave up" status
end;
FStar.IO.print_newline ()
end
let witnesses_for (print_test_case: (Seq.seq int -> list string -> ML unit)) (z3: Z3.z3) (name: string) (l: list arg_type) (nargs: nat { nargs == count_args l }) mk_get_first_witness mk_want_another_witness nbwitnesses =
z3.to_z3 "(push)\n";
z3.to_z3 mk_get_first_witness;
want_witnesses print_test_case z3 name l nargs mk_want_another_witness nbwitnesses;
z3.to_z3 "(pop)\n"
let rec mk_call_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_call_args (Printf.sprintf "%s 0" accu) i q
| _ :: q -> mk_call_args (Printf.sprintf "%s arg-%d" accu i) (i + 1) q
let rec mk_assert_args (accu: string) (i: nat) (l: list arg_type) : Tot string (decreases l) =
match l with
| [] -> accu
| ArgPointer :: q -> mk_assert_args accu i q
| ArgBool :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Bool)\n" accu i) (i + 1) q
| ArgInt it :: q -> mk_assert_args (Printf.sprintf "%s(declare-fun arg-%d () Int)\n(assert (and (<= 0 arg-%d) (< arg-%d %d)))\n" accu i i i (pow2 (integer_type_bit_size it))) (i + 1) q | false | true | Z3TestGen.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_get_witness (name: string) (l: list arg_type) : string | [] | Z3TestGen.mk_get_witness | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | name: Prims.string -> l: Prims.list Z3TestGen.arg_type -> Prims.string | {
"end_col": 25,
"end_line": 1066,
"start_col": 0,
"start_line": 1057
} |
Prims.Pure | val parse_typ (t: I.typ)
: Pure (parser not_reading) (requires (type_has_actions t == false)) (ensures (fun _ -> True)) | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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 parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false))
(ensures (fun _ -> True))
= match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) -> parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) -> parse_dep_pair_with_refinement (parse_readable_dtyp base) lam_cond (fun _ -> mk_expr cond) lam_k (parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator -> parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body) | val parse_typ (t: I.typ)
: Pure (parser not_reading) (requires (type_has_actions t == false)) (ensures (fun _ -> True))
let rec parse_typ (t: I.typ)
: Pure (parser not_reading) (requires (type_has_actions t == false)) (ensures (fun _ -> True)) = | false | null | false | match t with
| I.T_false _ -> parse_false
| I.T_denoted _ d -> parse_denoted d
| I.T_pair _ t1 t2 -> parse_pair (parse_typ t1) (parse_typ t2)
| I.T_dep_pair _ t1 (lam, t2) -> parse_dep_pair (parse_readable_dtyp t1) lam (parse_typ t2)
| I.T_refine _ base (lam, cond) ->
parse_refine (parse_readable_dtyp base) lam (fun _ -> mk_expr cond)
| I.T_dep_pair_with_refinement _ base (lam_cond, cond) (lam_k, k) ->
parse_dep_pair_with_refinement (parse_readable_dtyp base)
lam_cond
(fun _ -> mk_expr cond)
lam_k
(parse_typ k)
| I.T_if_else cond t1 t2 -> parse_ifthenelse (fun _ -> mk_expr cond) (parse_typ t1) (parse_typ t2)
| I.T_with_comment _ base _ -> parse_typ base
| I.T_at_most _ size body -> parse_at_most (fun _ -> mk_expr size) (parse_typ body)
| I.T_exact _ size body -> parse_exact (fun _ -> mk_expr size) (parse_typ body)
| I.T_string _ elt terminator ->
parse_string (parse_readable_dtyp elt) (fun _ -> mk_expr terminator)
| I.T_nlist _ size body -> parse_nlist (fun _ -> mk_expr size) (parse_typ body) | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [] | [
"InterpreterTarget.typ",
"InterpreterTarget.non_empty_string",
"Z3TestGen.parse_false",
"InterpreterTarget.dtyp",
"Z3TestGen.parse_denoted",
"Z3TestGen.parse_pair",
"Z3TestGen.parse_typ",
"InterpreterTarget.readable_dtyp",
"Ast.ident",
"Z3TestGen.parse_dep_pair",
"Z3TestGen.parse_readable_dtyp",
"InterpreterTarget.expr",
"Z3TestGen.parse_refine",
"Prims.unit",
"Z3TestGen.mk_expr",
"Prims.string",
"Z3TestGen.parse_dep_pair_with_refinement",
"Z3TestGen.parse_ifthenelse",
"Z3TestGen.parse_at_most",
"Z3TestGen.parse_exact",
"Z3TestGen.parse_string",
"Z3TestGen.parse_nlist",
"Z3TestGen.parser",
"Z3TestGen.not_reading",
"Prims.eq2",
"Prims.bool",
"Z3TestGen.type_has_actions",
"Prims.l_True"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
"
let mk_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false"
let mk_app fn = function
| None -> fn
| Some args -> Printf.sprintf "(%s %s)" fn args
let assert_some = function
| None -> failwith "assert_some"
| Some x -> x
let is_bitwise_op (x: T.op) : Tot (option A.integer_type) =
match x with
| T.BitwiseAnd a
| T.BitwiseXor a
| T.BitwiseOr a
| T.BitwiseNot a
| T.ShiftLeft a
| T.ShiftRight a
-> Some a
| _ -> None
let mk_bitwise_op (op: string) (bitvec_args: option string) : ML string =
mk_app "bv2int" (Some (mk_app op bitvec_args))
let integer_type_bit_size = function
| A.UInt8 -> 8
| A.UInt16 -> 16
| A.UInt32 -> 32
| A.UInt64 -> 64
let mk_bitwise_not (a: A.integer_type) (bitvec_arg: option string) : ML string =
match bitvec_arg with
| None -> failwith "ill-formed bitwise_not"
| Some arg -> "(bv2int (bvxor "^arg^" #b"^String.make (integer_type_bit_size a) '1'^"))"
let mk_op : T.op -> option string -> ML string = function
| T.Eq -> mk_app "="
| T.Neq -> (fun s -> mk_app "not" (Some (mk_app "=" s)))
| T.And -> mk_app "and"
| T.Or -> mk_app "or"
| T.Not -> mk_app "not"
| T.Plus _ -> mk_app "+"
| T.Minus _ -> mk_app "-"
| T.Mul _ -> mk_app "*"
| T.Division _ -> mk_app "div"
| T.Remainder _ -> mk_app "mod"
| T.BitwiseAnd _ -> mk_bitwise_op "bvand"
| T.BitwiseXor _ -> mk_bitwise_op "bvxor"
| T.BitwiseOr _ -> mk_bitwise_op "bvor"
| T.BitwiseNot a -> mk_bitwise_not a
| T.ShiftLeft _ -> mk_bitwise_op "bvshl"
| T.ShiftRight _ -> mk_bitwise_op "bvlshr"
| T.LT _ -> mk_app "<"
| T.GT _ -> mk_app ">"
| T.LE _ -> mk_app "<="
| T.GE _ -> mk_app ">="
| T.IfThenElse -> mk_app "if"
| T.BitFieldOf size order -> (fun arg -> Printf.sprintf "(get-bitfield-%ssb %d %s)" (match order with A.LSBFirst -> "l" | A.MSBFirst -> "m") size (assert_some arg))
| T.Cast _ _ -> assert_some (* casts allowed only if they are proven not to lose precision *)
| T.Ext s -> mk_app s
let ident_to_string = A.ident_to_string
let mk_bitwise_arg (t: A.integer_type) (arg: string) : Tot string =
mk_app ("(_ int2bv "^string_of_int (integer_type_bit_size t)^")") (Some arg)
let mk_maybe_bitwise_arg (t: option A.integer_type) (arg: string) : Tot string =
match t with
| None -> arg
| Some t -> mk_bitwise_arg t arg
let rec mk_expr (e: T.expr) : ML string = match fst e with
| T.Constant c -> mk_constant c
| T.Identifier i -> ident_to_string i
| T.App hd args -> mk_op hd (mk_args (is_bitwise_op hd) args)
| _ -> failwith "mk_expr: not supported"
and mk_args_aux (is_bitwise_op: option A.integer_type) accu : (list T.expr -> ML string) = function
| [] -> accu
| a :: q -> mk_args_aux is_bitwise_op (Printf.sprintf "%s %s" accu (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a))) q
and mk_args (is_bitwise_op: option A.integer_type) (l: list T.expr) : ML (option string) = match l with
| [] -> None
| a :: q -> Some (mk_args_aux is_bitwise_op (mk_maybe_bitwise_arg is_bitwise_op (mk_expr a)) q)
type reading = { call: string }
type not_reading = { call: string }
type binders = {
is_empty: bool;
bind: string;
args: string;
}
let empty_binders : binders = {
is_empty = true;
bind = "";
args = "";
}
let push_binder (name: string) (typ: string) (b: binders) : binders = {
is_empty = false;
bind = Printf.sprintf "(%s %s) %s" name typ b.bind;
args = Printf.sprintf " %s%s" name b.args;
}
let mk_function_call (name: string) (b: binders) =
Printf.sprintf "%s%s" name b.args
type parser (a: Type) =
(* name *) string ->
(* binders *) binders ->
(* is_toplevel *) bool ->
(* out *) (string -> ML unit) ->
ML a
let unsupported_parser (s: string) (a: Type) : Tot (parser a) =
fun _ _ _ _ -> failwith (Printf.sprintf "unsupported parser: %s" s)
let leaf_reading_parser (name: string) : parser reading =
fun _ _ _ _ -> { call = name }
let readable_itype_parser_suffix (i: I.itype) : Tot string = match i with
| I.UInt8 | I.UInt8BE -> "u8"
| I.UInt16 -> "u16-le"
| I.UInt16BE -> "u16-be"
| I.UInt32 -> "u32-le"
| I.UInt32BE -> "u32-be"
| I.UInt64 -> "u64-le"
| I.UInt64BE -> "u64-be"
| I.Unit -> "empty"
| I.AllBytes -> "all-bytes"
| I.AllZeros -> "all-zeros"
let parse_readable_itype (i: I.readable_itype) : Tot (parser reading) =
leaf_reading_parser ("parse-" ^ readable_itype_parser_suffix i)
let mk_wrap_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(after-state ("^body^" "^input^"))
)
"
let wrap_parser (p: parser reading) : parser not_reading =
fun name binders _ out ->
let name' = Printf.sprintf "%s-wrapped" name in
let body = p name' binders false out in
out (mk_wrap_parser name binders.bind body.call);
{ call = mk_function_call name binders }
let mk_toplevel_parser
(name: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
("^body^" "^input^")
)
"
let maybe_toplevel_parser (p: parser not_reading) : parser not_reading =
fun name binders is_toplevel out ->
if is_toplevel
then begin
let name' = Printf.sprintf "%s-body" name in
let body = p name' binders false out in
out (mk_toplevel_parser name binders.bind body.call);
{ call = mk_function_call name binders }
end
else p name binders false out
let parse_all_bytes : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-bytes" })
let parse_all_zeros : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-all-zeros" })
let parse_itype : I.itype -> parser not_reading = function
| I.AllBytes -> parse_all_bytes
| I.AllZeros -> parse_all_zeros
| i -> wrap_parser (parse_readable_itype i)
let mk_app_without_paren id args =
mk_args_aux None (ident_to_string id) args
let parse_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser reading)
= fun _ _ _ _ -> { call = mk_app_without_paren hd args }
let parse_readable_dtyp
(d: I.readable_dtyp)
: Tot (parser reading)
= match d with
| I.DT_IType i -> parse_readable_itype i
| I.DT_App _ hd args -> parse_readable_app hd args
let parse_not_readable_app
(hd: A.ident)
(args: list I.expr)
: Tot (parser not_reading)
= maybe_toplevel_parser (fun _ _ _ _ -> { call = mk_app_without_paren hd args })
let parse_dtyp
(d: I.dtyp)
: Tot (parser not_reading)
= if I.allow_reader_of_dtyp d
then wrap_parser (parse_readable_dtyp d)
else match d with
| I.DT_IType i -> parse_itype i
| I.DT_App _ hd args -> parse_not_readable_app hd args
let parse_false : parser not_reading =
maybe_toplevel_parser (fun _ _ _ _ -> { call = "parse-false" })
let parse_denoted (d: I.dtyp) : parser not_reading =
parse_dtyp d
let mk_parse_pair
(name: string)
(binders: string)
(fst: string)
(snd: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^fst^" "^input^")))
(if (< (input-size "^tmp^") 0)
"^tmp^"
("^snd^" "^tmp^")
)
)
)
"
let parse_pair (fst: parser not_reading) (snd: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_fst = Printf.sprintf "%s-fst" name in
let body_fst = fst name_fst binders false out in
let name_snd = Printf.sprintf "%s-snd" name in
let body_snd = snd name_snd binders false out in
out (mk_parse_pair name binders.bind body_fst.call body_snd.call);
{ call = mk_function_call name binders }
let parse_square (p: parser not_reading) : parser not_reading =
fun name binders _ out ->
let body_name = Printf.sprintf "%s-snd" name in
let body = p body_name binders false out in
out (mk_parse_pair name binders.bind body.call body.call);
{ call = mk_function_call name binders }
let mk_parse_dep_pair_with_refinement
(name: string)
(binders: string)
(dfst: string)
(cond_binder_name: string)
(cond: string)
(dsnd_binder_name: string)
(dsnd: string) (* already contains the new argument *)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^dfst^" "^input^")))
(if (< (input-size (after-state "^tmp^")) 0)
(after-state "^tmp^")
(if (let (("^cond_binder_name^" (return-value "^tmp^"))) "^cond^")
(let (("^dsnd_binder_name^" (return-value "^tmp^")))
("^dsnd^" (after-state "^tmp^"))
)
(mk-state -1 (choice-index (after-state "^tmp^")))
)
)
)
)
"
let parse_dep_pair_with_refinement_gen (tag: parser reading) (cond_binder: string) (cond: unit -> ML string) (payload_binder: string) (payload: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_tag = Printf.sprintf "%s-tag" name in
let body_tag = tag name_tag binders false out in
let binders' = push_binder payload_binder "Int" binders in (* TODO: support more types *)
let name_payload = Printf.sprintf "%s-payload" name in
let body_payload = payload name_payload binders' false out in
out (mk_parse_dep_pair_with_refinement name binders.bind body_tag.call cond_binder (cond ()) payload_binder body_payload.call);
{ call = mk_function_call name binders }
let parse_dep_pair_with_refinement (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) (payload_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement_gen tag (ident_to_string cond_binder) cond (ident_to_string payload_binder) payload
let parse_dep_pair (tag: parser reading) (new_binder: A.ident) (payload: parser not_reading) : parser not_reading =
parse_dep_pair_with_refinement tag new_binder (fun _ -> "true") new_binder payload
let parse_refine (tag: parser reading) (cond_binder: A.ident) (cond: unit -> ML string) : parser not_reading =
parse_dep_pair_with_refinement tag cond_binder cond cond_binder (parse_itype I.Unit)
let mk_parse_ifthenelse
(name: string)
(binders: string)
(cond: string)
(f_then: string)
(f_else: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(if "^cond^"
("^f_then^" "^input^")
("^f_else^" "^input^")
)
)
"
let parse_ifthenelse (cond: unit -> ML string) (pthen: parser not_reading) (pelse: parser not_reading) : parser not_reading =
fun name binders _ out ->
let name_then = Printf.sprintf "%s-then" name in
let body_then = pthen name_then binders false out in
let name_else = Printf.sprintf "%s-else" name in
let body_else = pelse name_else binders false out in
out (mk_parse_ifthenelse name binders.bind (cond ()) body_then.call body_else.call);
{ call = mk_function_call name binders }
let mk_parse_exact
(name: string)
(binders: string)
(body: string)
(size: string)
: string
= let input = Printf.sprintf "%s-input" name in
let sz = Printf.sprintf "%s-size" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" State)) State
(let (("^sz^" "^size^"))
(if (< (input-size "^input^") "^sz^")
(mk-state -1 (choice-index "^input^"))
(let (("^res^" ("^body^" (mk-state "^sz^" (choice-index "^input^")))))
(mk-state
(if (= (input-size "^res^") 0)
(- (input-size "^input^") "^sz^")
-1
)
(choice-index "^res^")
)
)
)
)
)
"
let parse_exact
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_exact name binders.bind body.call (size ()));
{ call = mk_function_call name binders }
let parse_at_most
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_pair body parse_all_bytes)
(*
let mk_parse_list_one
(name: string)
(binders: string)
(p: string)
: string
= let input = Printf.sprintf "%s-input" name in
let res = Printf.sprintf "%s-res" name in
"(define-fun "^name^" ("^binders^"("^input^" (Seq Int))) (Seq Int)
(if (= (seq.len "^input^") 0)
(seq.unit 0)
(let (("^res^" ("^p^" "^input^")))
(if (= (seq.len "^res^") 0)
(as seq.empty (Seq Int))
(if (= (seq.nth "^res^" 0) 0)
(as seq.empty (Seq Int))
"^res^"
)
)
)
)
)
"
let parse_list_one
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list_one name binders.bind body.call);
{ call = mk_function_call name binders }
let rec parse_list_bounded'
(body: parser not_reading)
(logn: nat)
: Tot (parser not_reading)
(decreases logn)
= if logn = 0
then parse_list_one body
else
let logn' = logn - 1 in
parse_square (parse_list_bounded' body logn')
let parse_list_bounded body = parse_list_bounded' body 3 // 64
*)
let mk_parse_list
(name: string)
(rec_call: string)
(binders: string)
(body: string)
: string
= let input = Printf.sprintf "%s-input" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(if (<= (input-size "^input^") 0)
"^input^"
("^rec_call^" ("^body^" "^input^"))
)
)
"
let parse_list
(body: parser not_reading)
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_list name rec_call binders.bind body.call);
{ call = rec_call }
let parse_nlist
(size: unit -> ML string)
(body: parser not_reading)
: Tot (parser not_reading)
= parse_exact size (parse_list body)
let mk_parse_string
(name: string)
(rec_call: string)
(binders: string)
(body: string)
(terminator: string)
: string
= let input = Printf.sprintf "%s-input" name in
let tmp = Printf.sprintf "%s-tmp" name in
"(define-fun-rec "^name^" ("^binders^"("^input^" State)) State
(let (("^tmp^" ("^body^" "^input^")))
(if (< (choice-index (after-state "^tmp^")) 0)
(mk-state -1 (choice-index (after-state "^tmp^")))
(if (= (return-value "^tmp^") "^terminator^")
(after-state "^tmp^")
("^rec_call^" (after-state "^tmp^"))
)
)
)
)
"
let parse_string
(body: parser reading)
(terminator: (unit -> ML string))
: Tot (parser not_reading)
= fun name binders _ out ->
let rec_call = mk_function_call name binders in
let body_name = Printf.sprintf "%s-body" name in
let body = body body_name binders false out in
out (mk_parse_string name rec_call binders.bind body.call (terminator ()));
{ call = rec_call }
let rec type_has_actions = function
| I.T_with_dep_action _ _ _
| I.T_dep_pair_with_action _ _ _ _
| I.T_refine_with_action _ _ _ _
| I.T_dep_pair_with_refinement_and_action _ _ _ _ _
| I.T_with_action _ _ _
-> true
| I.T_false _
| I.T_denoted _ _
| I.T_refine _ _ _
| I.T_string _ _ _
-> false
| I.T_if_else _ t1 t2
| I.T_pair _ t1 t2 ->
type_has_actions t1 || type_has_actions t2
| I.T_at_most _ _ t
| I.T_exact _ _ t
| I.T_nlist _ _ t
| I.T_with_comment _ t _
| I.T_dep_pair_with_refinement _ _ _ (_, t)
| I.T_dep_pair _ _ (_, t) ->
type_has_actions t
let rec parse_typ (t : I.typ) : Pure (parser not_reading)
(requires (type_has_actions t == false)) | false | false | Z3TestGen.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 parse_typ (t: I.typ)
: Pure (parser not_reading) (requires (type_has_actions t == false)) (ensures (fun _ -> True)) | [
"recursion"
] | Z3TestGen.parse_typ | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | t: InterpreterTarget.typ -> Prims.Pure (Z3TestGen.parser Z3TestGen.not_reading) | {
"end_col": 81,
"end_line": 742,
"start_col": 2,
"start_line": 730
} |
FStar.All.ALL | [
{
"abbrev": true,
"full_module": "InterpreterTarget",
"short_module": "I"
},
{
"abbrev": true,
"full_module": "Target",
"short_module": "T"
},
{
"abbrev": true,
"full_module": "Ast",
"short_module": "A"
},
{
"abbrev": false,
"full_module": "FStar.Mul",
"short_module": null
},
{
"abbrev": false,
"full_module": "FStar.All",
"short_module": null
},
{
"abbrev": true,
"full_module": "FStar.Printf",
"short_module": "Printf"
},
{
"abbrev": false,
"full_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_constant = function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false" | let mk_constant = | true | null | false | function
| A.Unit -> "0"
| A.Int _ x -> string_of_int x
| A.XInt _ x -> string_of_int (OS.int_of_string x)
| A.Bool true -> "true"
| A.Bool false -> "false" | {
"checked_file": "Z3TestGen.fst.checked",
"dependencies": [
"Z3.fsti.checked",
"Target.fsti.checked",
"prims.fst.checked",
"OS.fsti.checked",
"Lisp.fsti.checked",
"InterpreterTarget.fsti.checked",
"FStar.String.fsti.checked",
"FStar.Seq.fst.checked",
"FStar.Printf.fst.checked",
"FStar.Pervasives.Native.fst.checked",
"FStar.Pervasives.fsti.checked",
"FStar.Mul.fst.checked",
"FStar.List.Tot.fst.checked",
"FStar.List.fst.checked",
"FStar.IO.fst.checked",
"FStar.Char.fsti.checked",
"FStar.All.fst.checked",
"Ast.fst.checked"
],
"interface_file": false,
"source_file": "Z3TestGen.fst"
} | [] | [
"Ast.constant",
"Prims.string",
"Ast.integer_type",
"Prims.int",
"Prims.string_of_int",
"OS.int_of_string"
] | [] | module Z3TestGen
module Printf = FStar.Printf
open FStar.All
open FStar.Mul
module A = Ast
module T = Target
module I = InterpreterTarget
let prelude : string =
"
(set-option :produce-models true)
(declare-datatypes () ((State (mk-state (input-size Int) (choice-index Int)))))
(declare-datatypes () ((Result (mk-result (return-value Int) (after-state State)))))
(define-fun parse-empty ((x State)) Result
(mk-result 0 x)
)
(declare-fun choose (Int) Int)
(assert (forall ((i Int))
(and (<= 0 (choose i)) (< (choose i) 256))
))
(define-fun parse-false ((x State)) State
(mk-state -1 (choice-index x))
)
(define-fun parse-all-bytes ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state 0 (+ (choice-index x) (input-size x)))
)
)
(define-fun parse-all-zeros ((x State)) State
(if (<= (input-size x) 0)
x
(mk-state
(if
(forall ((j Int))
(if (and (<= 0 j) (< j (input-size x)))
(= (choose (+ (choice-index x) j)) 0)
true
)
)
0
-1
)
(+ (choice-index x) (input-size x))
)
)
)
(define-fun parse-u8 ((x State)) Result
(mk-result
(choose (choice-index x))
(mk-state (- (input-size x) 1) (+ (choice-index x) 1))
)
)
(define-fun parse-u16-be ((x State)) Result
(mk-result
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u16-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(choose (+ 1 (choice-index x)))
)
)
(mk-state (- (input-size x) 2) (+ (choice-index x) 2))
)
)
(define-fun parse-u32-be ((x State)) Result
(mk-result
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u32-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(choose (+ 3 (choice-index x)))
)
)
)
)
)
)
(mk-state (- (input-size x) 4) (+ (choice-index x) 4))
)
)
(define-fun parse-u64-be ((x State)) Result
(mk-result
(+ (choose (+ 7 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(choose (+ 0 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun parse-u64-le ((x State)) Result
(mk-result
(+ (choose (+ 0 (choice-index x)))
(* 256
(+ (choose (+ 1 (choice-index x)))
(* 256
(+ (choose (+ 2 (choice-index x)))
(* 256
(+ (choose (+ 3 (choice-index x)))
(* 256
(+ (choose (+ 4 (choice-index x)))
(* 256
(+ (choose (+ 5 (choice-index x)))
(* 256
(+ (choose (+ 6 (choice-index x)))
(* 256
(choose (+ 7 (choice-index x)))
)
)
)
)
)
)
)
)
)
)
)
)
)
)
(mk-state (- (input-size x) 8) (+ (choice-index x) 8))
)
)
(define-fun-rec pow-2 ((amount Int)) Int
(if (<= amount 0)
1
(* 2 (pow-2 (- amount 1)))
)
)
;; see LowParse.BitFields.get_bitfield_eq
(define-fun get-bitfield-lsb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(mod (div value (pow-2 bitsFrom)) (pow-2 (- bitsTo bitsFrom)))
)
;; see EverParse3d.Prelude.StaticHeader
(define-fun get-bitfield-msb ((nbBits Int) (value Int) (bitsFrom Int) (bitsTo Int)) Int
(get-bitfield-lsb nbBits value (- nbBits bitsTo) (- nbBits bitsFrom))
)
(declare-const initial-input-size Int)
(assert (>= initial-input-size 0))
(define-fun initial-state () State (mk-state initial-input-size 0))
" | false | false | Z3TestGen.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_constant : _: Ast.constant -> FStar.All.ALL Prims.string | [] | Z3TestGen.mk_constant | {
"file_name": "src/3d/Z3TestGen.fst",
"git_rev": "446a08ce38df905547cf20f28c43776b22b8087a",
"git_url": "https://github.com/project-everest/everparse.git",
"project_name": "everparse"
} | _: Ast.constant -> FStar.All.ALL Prims.string | {
"end_col": 27,
"end_line": 220,
"start_col": 18,
"start_line": 215
} |
Subsets and Splits