diff --git a/Makefile b/Makefile
index 904a52395326f043296e6235f3433ca62c96da0b..40e7ba2de37519e1f8878a0a4aaf1a44a40c0e4b 100644
--- a/Makefile
+++ b/Makefile
@@ -313,6 +313,7 @@ DISTRIB_FILES:=\
$(wildcard src/kernel_internals/typing/*.ml*) \
$(wildcard src/kernel_services/ast_data/*.ml*) \
$(wildcard src/kernel_services/ast_queries/*.ml*) \
+ $(wildcard src/kernel_services/ast_building/*.ml*) \
$(wildcard src/kernel_services/ast_printing/*.ml*) \
$(wildcard src/kernel_services/cmdline_parameters/*.ml*) \
$(wildcard src/kernel_services/analysis/*.ml*) \
@@ -622,7 +623,8 @@ KERNEL_CMO=\
src/kernel_internals/runtime/dump_config.cmo \
src/kernel_services/ast_transformations/contract_special_float.cmo \
src/kernel_internals/runtime/special_hooks.cmo \
- src/kernel_internals/runtime/messages.cmo
+ src/kernel_internals/runtime/messages.cmo \
+ src/kernel_services/ast_building/cil_builder.cmo \
CMO += $(KERNEL_CMO)
diff --git a/headers/header_spec.txt b/headers/header_spec.txt
index 1b31299d8c2ad05fe41c32e4e1ec5b49bb003981..8d04294f438d5f367ae16f8bf87f2a5784f219f0 100644
--- a/headers/header_spec.txt
+++ b/headers/header_spec.txt
@@ -513,6 +513,8 @@ src/kernel_services/analysis/undefined_sequence.ml: CEA_LGPL
src/kernel_services/analysis/undefined_sequence.mli: CEA_LGPL
src/kernel_services/analysis/wto_statement.ml: CEA_LGPL
src/kernel_services/analysis/wto_statement.mli: CEA_LGPL
+src/kernel_services/ast_building/cil_builder.ml: CEA_LGPL
+src/kernel_services/ast_building/cil_builder.mli: CEA_LGPL
src/kernel_services/ast_data/README.md: .ignore
src/kernel_services/ast_data/alarms.ml: CEA_LGPL
src/kernel_services/ast_data/alarms.mli: CEA_LGPL
@@ -1488,7 +1490,6 @@ src/plugins/variadic/replacements.mli: CEA_LGPL_OR_PROPRIETARY
src/plugins/variadic/replacements.ml: CEA_LGPL_OR_PROPRIETARY
src/plugins/variadic/standard.ml: CEA_LGPL_OR_PROPRIETARY
src/plugins/variadic/translate.ml: CEA_LGPL_OR_PROPRIETARY
-src/plugins/variadic/va_build.ml: CEA_LGPL_OR_PROPRIETARY
src/plugins/variadic/va_types.mli: CEA_LGPL_OR_PROPRIETARY
src/plugins/wp/.gitignore: .ignore
src/plugins/wp/.ocp-indent: .ignore
diff --git a/share/Makefile.common b/share/Makefile.common
index fb4f37394e1c4ed99053d34d30e4ceb46df88c10..a74d9e018654b99f4610a31c310a77b9e4e0ebce 100644
--- a/share/Makefile.common
+++ b/share/Makefile.common
@@ -43,6 +43,7 @@ FRAMAC_SRC_DIRS= plugins/pdg_types plugins/value_types \
kernel_services/ast_data \
kernel_services/ast_queries \
kernel_services/ast_printing \
+ kernel_services/ast_building \
kernel_services/cmdline_parameters \
kernel_services/plugin_entry_points \
kernel_services/abstract_interp \
diff --git a/src/kernel_services/ast_building/cil_builder.ml b/src/kernel_services/ast_building/cil_builder.ml
new file mode 100644
index 0000000000000000000000000000000000000000..a01c5184db4fab9e995d6ddcd2624f9695a54962
--- /dev/null
+++ b/src/kernel_services/ast_building/cil_builder.ml
@@ -0,0 +1,1251 @@
+(**************************************************************************)
+(* *)
+(* This file is part of Frama-C. *)
+(* *)
+(* Copyright (C) 2007-2021 *)
+(* CEA (Commissariat à l'énergie atomique et aux énergies *)
+(* alternatives) *)
+(* *)
+(* you can redistribute it and/or modify it under the terms of the GNU *)
+(* Lesser General Public License as published by the Free Software *)
+(* Foundation, version 2.1. *)
+(* *)
+(* It is distributed in the hope that it will be useful, *)
+(* but WITHOUT ANY WARRANTY; without even the implied warranty of *)
+(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *)
+(* GNU Lesser General Public License for more details. *)
+(* *)
+(* See the GNU Lesser General Public License version 2.1 *)
+(* for more details (enclosed in the file licenses/LGPLv2.1). *)
+(* *)
+(**************************************************************************)
+
+let unknown_loc = Cil_datatype.Location.unknown
+
+
+(* --- Types --- *)
+
+module Type =
+struct
+ exception NotACType
+
+ type ('value,'shape) morphology =
+ | Single : ('value,'value) morphology
+ | Listed : ('value,'shape) typ -> ('value,'shape list) morphology
+
+ and ('value,'shape) typ = ('value,'shape) morphology * Cil_types.logic_type
+
+ open Cil_types
+
+ (* Logic types *)
+
+ let of_ltyp t = Single, t
+ let integer = Single, Linteger
+ let real = Single, Lreal
+
+ (* C base types *)
+
+ let of_ctyp t = Single, Ctype t
+ let void = Single, Ctype (TVoid [])
+ let bool = Single, Ctype (TInt (IBool, []))
+ let char = Single, Ctype (TInt (IChar, []))
+ let schar = Single, Ctype (TInt (ISChar, []))
+ let uchar = Single, Ctype (TInt (IUChar, []))
+ let int = Single, Ctype (TInt (IInt, []))
+ let unit = Single, Ctype (TInt (IUInt, []))
+ let short = Single, Ctype (TInt (IShort, []))
+ let ushort = Single, Ctype (TInt (IUShort, []))
+ let long = Single, Ctype (TInt (ILong, []))
+ let ulong = Single, Ctype (TInt (IULong, []))
+ let longlong = Single, Ctype (TInt (ILongLong, []))
+ let ulonglong = Single, Ctype (TInt (IULongLong, []))
+ let float = Single, Ctype (TFloat (FFloat, []))
+ let double = Single, Ctype (TFloat (FDouble, []))
+ let longdouble = Single, Ctype (TFloat (FLongDouble, []))
+
+ let ptr = function
+ | _, Ctype t -> Single, Ctype (TPtr (t, []))
+ | _, _ -> raise NotACType
+
+ let array ?size = function
+ | (_,Ctype t) as typ ->
+ let to_exp = Cil.integer ~loc:unknown_loc in
+ let size = Option.map to_exp size in
+ Listed typ,
+ Ctype (TArray (t, size, Cil.empty_size_cache (), []))
+ | _, _ -> raise NotACType
+
+
+ (* Attrbutes *)
+
+ let attribute (s,t) name params =
+ let add_to = Cil.addAttribute (Attr (name, params)) in
+ let t = match t with
+ | Ctype t -> t
+ | _ -> raise NotACType
+ in
+ let t = match t with
+ | TVoid l -> TVoid (add_to l)
+ | TInt (kind, l) -> TInt (kind, add_to l)
+ | TFloat (kind, l) -> TFloat (kind, add_to l)
+ | TPtr (typ, l) -> TPtr (typ, add_to l)
+ | TArray (typ, size, cache, l) -> TArray (typ, size, cache, add_to l)
+ | TFun (typ, args, variadic, l) -> TFun (typ, args, variadic, add_to l)
+ | TNamed (typeinfo, l) -> TNamed (typeinfo, add_to l)
+ | TComp (compinfo, cache, l) -> TComp (compinfo, cache, add_to l)
+ | TEnum (enuminfo, l) -> TEnum (enuminfo, add_to l)
+ | TBuiltin_va_list l -> TBuiltin_va_list (add_to l)
+ in
+ (s,Ctype t)
+
+ let const typ = attribute typ "const" []
+ let stdlib_generated typ = attribute typ "fc_stdlib_generated" []
+
+
+ (* Conversion *)
+
+ let cil_typ = function
+ | _, Ctype ty -> ty
+ | _, _ -> raise NotACType
+
+ let cil_logic_type (_,t) = t
+end
+
+
+(* --- C & Logic expressions builder --- *)
+
+module Exp =
+struct
+ include Type
+
+ (*
+ This module exports polymorphic variant to simulate subtyping.
+ It uses regular variant internally though, instead of using only the
+ polymorphic variant, as
+ 1. it simplifies greatly the .mli since most of the types don't have
+ to be exposed ; it also greatly simplifies mistyping errors for the user
+ 2. recursive polymorphic variants do not allow inclusion of one into another
+ 3. it is much easier to type the program with regular variants
+ *)
+
+ type label = Cil_types.logic_label
+
+ type const' =
+ | Int of int
+ | Integer of Integer.t
+ | CilConstant of Cil_types.constant
+ and var' =
+ Cil_types.varinfo
+ and lval' =
+ | CilLval of Cil_types.lval
+ | Var of var'
+ | Result
+ | Mem of exp'
+ | Index of lval' * exp'
+ | Field of lval' * Cil_types.fieldinfo
+ | FieldNamed of lval' * string
+ and exp' =
+ | CilExp of Cil_types.exp
+ | CilExpCopy of Cil_types.exp
+ | CilTerm of Cil_types.term
+ | Lval of lval'
+ | Const of const'
+ | Range of exp' option * exp' option
+ | Unop of Cil_types.unop * exp'
+ | Binop of Cil_types.binop * exp' * exp'
+ | Cast of Cil_types.logic_type * exp'
+ | Addr of lval'
+ | App of Cil_types.logic_info * label list * exp' list
+ | Pred of pred'
+ and pred' =
+ | ObjectPointer of label * exp'
+ | Valid of label * exp'
+ | ValidRead of label * exp'
+ | Initialized of label * exp'
+ | Dangling of label * exp'
+ | Allocable of label * exp'
+ | Freeable of label * exp'
+ | Fresh of label * label * exp' * exp'
+ and init' =
+ | CilInit of Cil_types.init
+ | SingleInit of exp'
+ | CompoundInit of Cil_types.typ * init' list
+
+ type const = [ `const of const' ]
+ type var = [ `var of var' ]
+ type lval = [ var | `lval of lval' ]
+ type exp = [ const | lval | `exp of exp' ]
+ type init = [ exp | `init of init']
+
+ (* Pretty printing *)
+
+ let rec pretty_const fmt = function
+ | Int i -> Format.pp_print_int fmt i
+ | Integer i -> Integer.pretty fmt i
+ | CilConstant c -> Printer.pp_constant fmt c
+ and pretty_var fmt v =
+ Printer.pp_varinfo fmt v
+ and pretty_lval fmt = function
+ | CilLval lv -> Printer.pp_lval fmt lv
+ | Var v -> pretty_var fmt v
+ | Result -> Format.fprintf fmt "%s" "\result"
+ | Mem e -> Format.fprintf fmt "*(%a)" pretty_exp e
+ | Index (lv,e) -> Format.fprintf fmt "%a[%a]" pretty_lval lv pretty_exp e
+ | Field (lv,fi) ->
+ Format.fprintf fmt "%a.%s" pretty_lval lv fi.Cil_types.fname
+ | FieldNamed (lv,s) -> Format.fprintf fmt "%a.%s" pretty_lval lv s
+ and pretty_exp fmt = function
+ | CilExp e -> Printer.pp_exp fmt e
+ | CilExpCopy e -> Printer.pp_exp fmt e
+ | CilTerm t -> Printer.pp_term fmt t
+ | Lval lv -> pretty_lval fmt lv
+ | Const c -> pretty_const fmt c
+ | Range (o1,o2) ->
+ Format.fprintf fmt "(%a .. %a)" pretty_exp_opt o1 pretty_exp_opt o2
+ | Unop (op,e) -> Format.fprintf fmt "%a%a" Printer.pp_unop op pretty_exp e
+ | Binop (op,e1,e2) ->
+ Format.fprintf fmt "(%a %a %a)"
+ pretty_exp e1
+ Printer.pp_binop op
+ pretty_exp e2
+ | Cast (lty, e) ->
+ Format.fprintf fmt "(%a)%a" Printer.pp_logic_type lty pretty_exp e
+ | Addr lv -> Format.fprintf fmt "&%a" pretty_lval lv
+ | App (li,labels,args) -> pretty_app fmt (li.l_var_info.lv_name,labels,args)
+ | Pred pred ->
+ pretty_pred fmt pred
+ and pretty_exp_opt fmt o =
+ Option.iter (pretty_exp fmt) o
+ and pretty_app fmt (name,labels,args) =
+ Format.fprintf fmt "%s{%a}(%a)"
+ name
+ (Pretty_utils.pp_list ~sep:",@ " Printer.pp_logic_label) labels
+ (Pretty_utils.pp_list ~sep:",@ " pretty_exp) args
+ and pretty_pred fmt = function
+ | ObjectPointer (l,e) -> pretty_app fmt ("object_pointer",[l],[e])
+ | Valid (l,e) -> pretty_app fmt ("valid",[l],[e])
+ | ValidRead (l,e) -> pretty_app fmt ("valid_read",[l],[e])
+ | Initialized (l,e) -> pretty_app fmt ("initialized",[l],[e])
+ | Dangling (l,e) -> pretty_app fmt ("dangling",[l],[e])
+ | Allocable (l,e) -> pretty_app fmt ("allocable",[l],[e])
+ | Freeable (l,e) -> pretty_app fmt ("freeable",[l],[e])
+ | Fresh (l1,l2,e1,e2) -> pretty_app fmt ("fresh",[l1;l2],[e1;e2])
+ and pretty_init fmt = function
+ | CilInit init -> Printer.pp_init fmt init
+ | SingleInit e -> pretty_exp fmt e
+ | CompoundInit (_,l) ->
+ Format.fprintf fmt "{%a}" (Pretty_utils.pp_list ~sep:",@ " pretty_init) l
+
+ let pretty fmt = function
+ | `none -> ()
+ | `const c -> pretty_const fmt c
+ | `var v -> pretty_var fmt v
+ | `lval lv -> pretty_lval fmt lv
+ | `exp e -> pretty_exp fmt e
+ | `init i -> pretty_init fmt i
+
+ (* Depolymorphize *)
+
+ let harden_const c =
+ match (c :> const) with
+ | `const const -> const
+
+ let harden_var v =
+ match (v :> var) with
+ | `var var -> var
+
+ let harden_lval lv =
+ match (lv :> lval) with
+ | #var as var -> Var (harden_var var)
+ | `lval lval -> lval
+
+ let harden_lval_opt = function
+ | `none -> None
+ | #lval as lval -> Some (harden_lval lval)
+
+ let harden_exp e =
+ match (e :> exp) with
+ | #const as const -> Const (harden_const const)
+ | #lval as lval -> Lval (harden_lval lval)
+ | `exp exp -> exp
+
+ let harden_exp_opt = function
+ | `none -> None
+ | #exp as exp -> Some (harden_exp exp)
+
+ let harden_exp_list l =
+ List.map harden_exp l
+
+ let harden_init i =
+ match (i :> init) with
+ | #exp as exp -> SingleInit (harden_exp exp)
+ | `init init -> init
+
+ (* None *)
+
+ let none = `none
+
+ (* Labels *)
+
+ let here = Cil_types.(BuiltinLabel Here)
+ let old = Cil_types.(BuiltinLabel Old)
+ let pre = Cil_types.(BuiltinLabel Pre)
+ let post = Cil_types.(BuiltinLabel Post)
+ let loop_entry = Cil_types.(BuiltinLabel LoopEntry)
+ let loop_current = Cil_types.(BuiltinLabel LoopCurrent)
+ let program_init = Cil_types.(BuiltinLabel Init)
+
+ (* Constants *)
+
+ let of_constant c = `const (CilConstant c)
+ let of_integer i = `const (Integer i)
+ let of_int i = `const (Int i)
+ let zero = of_int 0
+ let one = of_int 1
+
+ (* Lvalues *)
+
+ let var v = `var v
+ let of_lval lv = `lval (CilLval lv)
+
+ (* Expressions *)
+
+ let of_exp e = `exp (CilExp e)
+ let of_exp_copy e = `exp (CilExpCopy e)
+ let unop op e = `exp (Unop (op, harden_exp e))
+ let neg e = unop Cil_types.Neg e
+ let lognot e = unop Cil_types.LNot e
+ let bwnot e = unop Cil_types.BNot e
+ let binop op e1 e2 = `exp (Binop (op, harden_exp e1, harden_exp e2))
+ let add e1 e2 = binop Cil_types.PlusA e1 e2
+ let succ e = add e one
+ let add_int e i = add e (of_int i)
+ let sub e1 e2 = binop Cil_types.MinusA e1 e2
+ let mul e1 e2 = binop Cil_types.Mult e1 e2
+ let div e1 e2 = binop Cil_types.Div e1 e2
+ let modulo e1 e2 = binop Cil_types.Mod e1 e2
+ let shiftl e1 e2 = binop Cil_types.Shiftlt e1 e2
+ let shiftr e1 e2 = binop Cil_types.Shiftrt e1 e2
+ let lt e1 e2 = binop Cil_types.Lt e1 e2
+ let gt e1 e2 = binop Cil_types.Gt e1 e2
+ let le e1 e2 = binop Cil_types.Le e1 e2
+ let ge e1 e2 = binop Cil_types.Ge e1 e2
+ let eq e1 e2 = binop Cil_types.Eq e1 e2
+ let ne e1 e2 = binop Cil_types.Ne e1 e2
+ let bwand e1 e2 = binop Cil_types.BAnd e1 e2
+ let bwor e1 e2 = binop Cil_types.BOr e1 e2
+ let bwxor e1 e2 = binop Cil_types.BXor e1 e2
+ let logand e1 e2 = binop Cil_types.LAnd e1 e2
+ let logor e1 e2 = binop Cil_types.LOr e1 e2
+ let cast' t e = `exp (Cast (Cil_types.Ctype t, harden_exp e))
+ let cast (_,t) e = `exp (Cast (t, harden_exp e))
+ let addr lv = `exp (Addr (harden_lval lv))
+ let mem e = `lval (Mem (harden_exp e))
+ let index lv e = `lval (Index (harden_lval lv, harden_exp e))
+ let field lv fi = `lval (Field (harden_lval lv, fi))
+ let fieldnamed lv s = `lval (FieldNamed (harden_lval lv, s))
+
+ (* Expression lists *)
+
+ exception EmptyList
+
+ let reduce f l =
+ match (l :> exp list) with
+ | [] -> raise EmptyList
+ | h :: t -> List.fold_left f h t
+
+ let logand_list l = reduce logand l
+ let logor_list l = reduce logor l
+
+ (* Term specific *)
+
+ let result = `lval Result
+ let term t = `exp (CilTerm t)
+ let range e1 e2 = `exp (Range (harden_exp_opt e1, harden_exp_opt e2))
+ let whole = `exp (Range (None, None))
+ let whole_right = `exp (Range (Some (Const (Int 0)), None))
+ let app logic_info labels args =
+ `exp (App (logic_info, labels, harden_exp_list args))
+
+ let object_pointer ?(at=here) e =
+ `exp (Pred (ObjectPointer (at, harden_exp e)))
+ let valid ?(at=here) e = `exp (Pred (Valid (at, harden_exp e)))
+ let valid_read ?(at=here) e = `exp (Pred (ValidRead (at, harden_exp e)))
+ let initialized ?(at=here) e = `exp (Pred (Initialized (at, harden_exp e)))
+ let dangling ?(at=here) e = `exp (Pred (Dangling (at, harden_exp e)))
+ let allocable ?(at=here) e = `exp (Pred (Allocable (at, harden_exp e)))
+ let freeable ?(at=here) e = `exp (Pred (Freeable (at, harden_exp e)))
+ let fresh l1 l2 e1 e2 =
+ `exp (Pred (Fresh (l1, l2, harden_exp e1, harden_exp e2)))
+
+ (* Initializations *)
+
+ let of_init i = `init (CilInit i)
+ let compound t l = `init (CompoundInit (t, List.map harden_init l))
+
+ let rec values : type a. (init, a) typ -> a -> [> init] =
+ fun ty x ->
+ match ty with
+ | Single, Ctype _ -> x
+ | Listed sub, Ctype t-> compound t (List.map (values sub) x)
+ | _, _ -> raise NotACType
+
+ (* Operators *)
+
+ let (+), (-), ( * ), (/), (%) = add, sub, mul, div, modulo
+ let (<<), (>>) = shiftl, shiftr
+ let (<), (>), (<=), (>=), (==), (!=) = lt, gt, le, ge, eq, ne
+ let (--) = range
+
+ (* Convert *)
+
+ exception LogicInC of exp
+ exception CInLogic of exp
+ exception NotATerm of exp
+ exception NotAPredicate of exp
+ exception NotAFunction of Cil_types.logic_info
+ exception Typing_error of string
+
+ let typing_error s =
+ raise (Typing_error s)
+
+ let get_field ci s =
+ try
+ Cil.getCompField ci s
+ with Not_found ->
+ typing_error ("no field " ^ s ^ " in " ^ ci.Cil_types.cname)
+
+
+ let rec build_constant = function
+ | CilConstant const -> const
+ | Int i -> build_constant (Integer (Integer.of_int i))
+ | Integer i -> Cil_types.(CInt64 (i, IInt, None))
+
+ and build_lval ~loc = function
+ | Result as lv -> raise (LogicInC (`lval lv))
+ | CilLval lval -> lval
+ | Var v -> Cil_types.(Var v, NoOffset)
+ | Mem e ->
+ let e' = build_exp ~loc e in
+ Cil.mkMem ~addr:e' ~off:Cil_types.NoOffset
+ | Index (lv, e) ->
+ let (host, offset) as lv' = build_lval ~loc lv
+ and e' = build_exp ~loc e in
+ begin match Cil.(unrollType (typeOfLval lv')) with
+ | TArray _ ->
+ let offset' = Cil_types.Index (e', NoOffset) in
+ host, Cil.addOffset offset' offset
+ | TPtr _ ->
+ let base = Cil.new_exp ~loc (Lval lv') in
+ let addr = Cil.mkBinOp ~loc Cil_types.PlusPI base e' in
+ Cil.mkMem ~addr ~off:Cil_types.NoOffset
+ | _ -> typing_error "trying to index an lvalue which is not an array \
+ or a pointer"
+ end
+ | (Field (lv,_) | FieldNamed (lv,_)) as e ->
+ let (host, offset) as lv' = build_lval ~loc lv in
+ let host', offset', ci = match Cil.(unrollTypeDeep (typeOfLval lv')) with
+ | TComp (ci,_,_) -> host, offset, ci
+ | TPtr (TComp (ci,_,_),_) ->
+ Mem (Cil.new_exp ~loc (Lval lv')), Cil_types.NoOffset, ci
+ | _ -> typing_error "trying to get a field of an lvalue which is not \
+ of composite type or pointer to a composite type"
+ in
+ let f = match e with
+ | Field (_lv,f) -> f
+ | FieldNamed (_lv,s) -> get_field ci s
+ | _ -> assert false
+ in
+ let offset'' = Cil_types.(Field (f, NoOffset)) in
+ host', Cil.addOffset offset'' offset'
+
+ and build_exp ~loc = function
+ | CilTerm _ | Range _ | App _ | Pred _ as e -> raise (LogicInC (`exp e))
+ | CilExp exp -> exp
+ | CilExpCopy exp -> Cil.copy_exp exp
+ | Const c->
+ Cil.new_exp ~loc (Cil_types.Const (build_constant c))
+ | Lval lval ->
+ Cil.new_exp ~loc (Cil_types.Lval (build_lval ~loc lval))
+ | Unop (op,e) ->
+ let e' = build_exp ~loc e in
+ let oldt = Cil.typeOf e' in
+ let newt = Cil.integralPromotion oldt in
+ Cil.(new_exp ~loc (Cil_types.UnOp (op, mkCastT ~oldt ~newt e', oldt)))
+ | Binop (op,e1,e2) ->
+ let is_pointer_type e =
+ Cil.(isPointerType (typeOf e))
+ in
+ let e1' = build_exp ~loc e1
+ and e2' = build_exp ~loc e2 in
+ let op' = match op with (* Normalize operation *)
+ | PlusA when is_pointer_type e1' -> Cil_types.PlusPI
+ | MinusA when is_pointer_type e1' -> Cil_types.MinusPI
+ | PlusPI when not (is_pointer_type e1') -> Cil_types.PlusA
+ | MinusPI when not (is_pointer_type e1') -> Cil_types.MinusA
+ | op -> op
+ in
+ Cil.mkBinOp ~loc op' e1' e2'
+ | Cast (Cil_types.Ctype newt, e) ->
+ Cil.mkCast ~force:false ~newt (build_exp ~loc e)
+ | Cast _ ->
+ raise NotACType
+ | Addr lv ->
+ Cil.mkAddrOrStartOf ~loc (build_lval ~loc lv)
+
+ let rec build_term_lval ~loc ~restyp = function
+ | Result -> Cil_types.(TResult (Option.get restyp), TNoOffset)
+ | CilLval _ as lv -> raise (CInLogic (`lval lv))
+ | Var v -> Cil_types.(TVar (Cil.cvar_to_lvar v), TNoOffset)
+ | Mem t ->
+ let t' = build_term ~loc ~restyp t in
+ Cil_types.(TMem t', TNoOffset)
+ | Index (tlv, t) ->
+ let (host, offset) as tlv' = build_term_lval ~loc ~restyp tlv
+ and t' = build_term ~loc ~restyp t in
+ let lty = Cil.typeOfTermLval tlv' in
+ begin match Logic_utils.unroll_type lty with
+ | Ctype (TArray _) ->
+ let offset' = Cil_types.(TIndex (t', TNoOffset)) in
+ host, Logic_const.addTermOffset offset' offset
+ | Ctype (TPtr _) ->
+ let base = Logic_const.term ~loc (TLval tlv') lty in
+ let addr = Logic_const.term ~loc (TBinOp (PlusPI,base,t')) lty in
+ TMem addr, TNoOffset
+ | _ -> typing_error "trying to index a term lvalue which is not a C \
+ array or a C pointer"
+ end
+ | (Field (tlv,_) | FieldNamed (tlv,_)) as t ->
+ let (host, offset) as tlv' = build_term_lval ~loc ~restyp tlv in
+ let lty = match Logic_utils.unroll_type (Cil.typeOfTermLval tlv') with
+ | Ctype cty -> Cil_types.Ctype (Cil.unrollTypeDeep cty)
+ | lty -> lty
+ in
+ let host', offset', ci = match lty with
+ | Ctype (TComp (ci,_,_)) -> host, offset, ci
+ | Ctype (TPtr (TComp (ci,_,_),_)) ->
+ TMem (Logic_const.term ~loc (Cil_types.TLval tlv') lty), TNoOffset, ci
+ | _ -> typing_error "trying to get a field of an lvalue which is not \
+ of composite type or pointer to a composite type"
+ in
+ let f = match t with
+ | Field (_lv,f) -> f
+ | FieldNamed (_lv,s) -> get_field ci s
+ | _ -> assert false
+ in
+ let offset'' = Cil_types.(TField (f, TNoOffset)) in
+ host', Logic_const.addTermOffset offset'' offset'
+
+ and build_term ~loc ~restyp = function
+ | Const (CilConstant _) | CilExp _ | CilExpCopy _ as e ->
+ raise (CInLogic (`exp e))
+ | Pred _ as e ->
+ raise (NotATerm (`exp e))
+ | CilTerm term -> term
+ | Const (Int i) ->
+ Logic_const.tinteger ~loc i
+ | Const (Integer i) ->
+ Logic_const.tint ~loc i
+ | Lval lval ->
+ let tlval = build_term_lval ~loc ~restyp lval in
+ Logic_const.term ~loc Cil_types.(TLval tlval) (Cil.typeOfTermLval tlval)
+ | Unop (op,t) ->
+ let t' = build_term t ~loc ~restyp in
+ let ty = t'.Cil_types.term_type in
+ (* TODO: type conversion *)
+ Logic_const.term ~loc Cil_types.(TUnOp (op,t')) ty
+ | Binop (op,t1,t2) ->
+ let t1' = build_term ~loc ~restyp t1
+ and t2' = build_term ~loc ~restyp t2 in
+ let ty = t1'.Cil_types.term_type in
+ let op' = match op with (* Normalize operation *)
+ | PlusA when Logic_utils.isLogicPointer t1' -> Cil_types.PlusPI
+ | MinusA when Logic_utils.isLogicPointer t1' -> Cil_types.MinusPI
+ | PlusPI when not (Logic_utils.isLogicPointer t1') -> Cil_types.PlusA
+ | MinusPI when not (Logic_utils.isLogicPointer t1') -> Cil_types.MinusA
+ | op -> op
+ in
+ (* TODO: type conversion *)
+ Logic_const.term ~loc Cil_types.(TBinOp (op',t1',t2')) ty
+ | Cast (Ctype ct, t) ->
+ let t' = build_term ~loc ~restyp t in
+ Logic_utils.mk_cast ~loc ct t'
+ | Cast (ty, t) ->
+ let t' = build_term ~loc ~restyp t in
+ Logic_utils.numeric_coerce ty t'
+ | Addr lval ->
+ let tlval = build_term_lval ~loc ~restyp lval in
+ let ty = Cil.typeOfTermLval tlval in
+ Logic_utils.mk_logic_AddrOf ~loc tlval ty
+ | Range (t1,t2) ->
+ let t1' = Option.map (build_term ~loc ~restyp) t1
+ and t2' = Option.map (build_term ~loc ~restyp) t2 in
+ Logic_const.trange ~loc (t1',t2')
+ | App (logic_info, labels, args) ->
+ let ty = match logic_info.l_type with
+ | None -> raise (NotAFunction logic_info)
+ | Some ty -> ty
+ in
+ let args' = List.map (build_term ~loc ~restyp) args in
+ Logic_const.term ~loc (Tapp (logic_info, labels, args')) ty
+
+ and build_relation e = function
+ | Cil_types.Lt -> Cil_types.Rlt
+ | Cil_types.Gt -> Cil_types.Rgt
+ | Cil_types.Le -> Cil_types.Rle
+ | Cil_types.Ge -> Cil_types.Rge
+ | Cil_types.Eq -> Cil_types.Req
+ | Cil_types.Ne -> Cil_types.Rneq
+ | _ -> raise (NotAPredicate (`exp e))
+
+ and build_pred_node ~loc ~restyp = function
+ | Unop (Cil_types.LNot, p) ->
+ let p' = build_pred ~loc ~restyp p in
+ Cil_types.Pnot p'
+ | Binop (Cil_types.LAnd, p1, p2) ->
+ let p1' = build_pred ~loc ~restyp p1
+ and p2' = build_pred ~loc ~restyp p2 in
+ Cil_types.Pand (p1',p2')
+ | Binop (Cil_types.LOr, p1, p2) ->
+ let p1' = build_pred ~loc ~restyp p1
+ and p2' = build_pred ~loc ~restyp p2 in
+ Cil_types.Por (p1',p2')
+ | Binop (binop, t1, t2) as e ->
+ let rel = build_relation e binop
+ and t1' = build_term ~loc ~restyp t1
+ and t2' = build_term ~loc ~restyp t2 in
+ Cil_types.Prel (rel, t1', t2')
+ | Const _ | CilExp _ | CilExpCopy _ | CilTerm _
+ | Lval _ | Unop _ | Cast _ | Addr _ | Range _ as e ->
+ raise (NotAPredicate (`exp e))
+ | App (logic_info, labels, args) ->
+ let args' = List.map (build_term ~loc ~restyp) args in
+ Cil_types.Papp (logic_info, labels, args')
+ | Pred (ObjectPointer (l, t)) ->
+ Cil_types.Pobject_pointer (l, build_term ~loc ~restyp t)
+ | Pred (Valid (l, t)) ->
+ Cil_types.Pvalid (l, build_term ~loc ~restyp t)
+ | Pred (ValidRead (l, t)) ->
+ Cil_types.Pvalid_read (l, build_term ~loc ~restyp t)
+ | Pred (Initialized (l, t)) ->
+ Cil_types.Pinitialized (l, build_term ~loc ~restyp t)
+ | Pred (Dangling (l, t)) ->
+ Cil_types.Pdangling (l, build_term ~loc ~restyp t)
+ | Pred (Allocable (l, t)) ->
+ Cil_types.Pallocable (l, build_term ~loc ~restyp t)
+ | Pred (Freeable (l, t)) ->
+ Cil_types.Pfreeable (l, build_term ~loc ~restyp t)
+ | Pred (Fresh (l1, l2, t1, t2)) ->
+ let t1' = build_term ~loc ~restyp t1
+ and t2' = build_term ~loc ~restyp t2 in
+ Cil_types.Pfresh (l1, l2, t1', t2')
+
+ and build_pred ~loc ~restyp t =
+ Logic_const.unamed ~loc (build_pred_node ~loc ~restyp t)
+
+ let rec build_init ~loc = function
+ | CilInit init -> init
+ | SingleInit e ->
+ Cil_types.SingleInit (build_exp ~loc e)
+ | CompoundInit (typ,l) ->
+ let index i = Cil_types.(Index (Cil.integer ~loc i, NoOffset)) in
+ let initl = List.mapi (fun i sub -> index i, build_init ~loc sub) l in
+ Cil_types.CompoundInit (typ, initl)
+
+
+ (* Export *)
+
+ let cil_logic_label label = label
+ let cil_varinfo v = harden_var v
+ let cil_constant c = build_constant (harden_const c)
+ let cil_lval ~loc lv = build_lval ~loc (harden_lval lv)
+ let cil_lval_opt ~loc lv =
+ Option.map (build_lval ~loc) (harden_lval_opt lv)
+ let cil_exp ~loc e = build_exp ~loc (harden_exp e)
+ let cil_exp_opt ~loc e = Option.map (build_exp ~loc) (harden_exp_opt e)
+ let cil_exp_list ~loc l = List.map (cil_exp ~loc) l
+ let cil_term_lval ~loc ?restyp lv =
+ build_term_lval ~loc ~restyp (harden_lval lv)
+ let cil_term ~loc ?restyp e = build_term ~loc ~restyp (harden_exp e)
+ let cil_iterm ~loc ?restyp e =
+ Logic_const.new_identified_term (cil_term ~loc ?restyp e)
+ let cil_pred ~loc ?restyp e = build_pred ~loc ~restyp (harden_exp e)
+ let cil_ipred ~loc ?restyp e =
+ Logic_const.new_predicate (cil_pred ~loc ?restyp e)
+ let cil_init ~loc i = build_init ~loc (harden_init i)
+
+ let cil_typeof (`var vi) = vi.Cil_types.vtype
+end
+
+
+(* --- Pure builder --- *)
+
+module Pure =
+struct
+ include Exp
+
+ type instr' =
+ | CilInstr of Cil_types.instr
+ | Skip
+ | Assign of lval' * exp'
+ | Call of lval' option * exp' * exp' list
+
+ type stmt' =
+ | CilStmt of Cil_types.stmt
+ | CilStmtkind of Cil_types.stmtkind
+ | Instr of instr'
+ | Sequence of stmt' list
+ | Ghost of stmt'
+
+ type instr = [ `instr of instr' ]
+ type stmt = [ instr | `stmt of stmt' ]
+
+ (* Sequences *)
+
+ let flatten_sequences l =
+ let rec add_one acc = function
+ | Sequence l -> add_list acc l
+ | stmt -> stmt :: acc
+ and add_list acc l =
+ List.fold_left add_one acc l
+ in
+ List.rev (add_list [] l)
+
+ (* Depolymorphize *)
+
+ let harden_instr i =
+ match (i :> instr) with
+ | `instr instr -> instr
+
+ let harden_stmt s =
+ match (s :> stmt) with
+ | #instr as instr -> Instr (harden_instr instr)
+ | `stmt stmt -> stmt
+
+ (* Build *)
+
+ let of_instr i = `instr (CilInstr i)
+ let skip = `instr Skip
+ let assign dest src = `instr (Assign (harden_lval dest, harden_exp src))
+ let incr dest = `instr (Assign (harden_lval dest, harden_exp (add dest one)))
+ let call res callee args =
+ `instr (Call (harden_lval_opt res, harden_exp callee, harden_exp_list args))
+
+ let of_stmtkind sk = `stmt (CilStmtkind sk)
+ let of_stmt s = `stmt (CilStmt s)
+ let of_stmts l = `stmt (Sequence (List.map (fun s -> CilStmt s) l))
+ let block l = `stmt (Sequence (List.map harden_stmt l))
+ let ghost s = `stmt (Ghost (harden_stmt s))
+
+
+ (* Convert *)
+
+ let build_instr ~loc = function
+ | CilInstr i -> i
+ | Skip ->
+ Cil_types.Skip (loc)
+ | Assign (dest,src) ->
+ Cil_types.Set (build_lval ~loc dest, build_exp ~loc src, loc)
+ | Call (dest,callee,args) ->
+ let dest' = Option.map (build_lval ~loc) dest
+ and callee' = build_exp ~loc callee
+ and args' = List.map (build_exp ~loc) args in
+ Cil_types.Call (dest', callee', args', loc)
+
+ let rec build_stmtkind ~loc ~ghost = function
+ | CilStmt s -> s.Cil_types.skind
+ | CilStmtkind sk -> sk
+ | Instr i -> Cil_types.Instr (build_instr ~loc i)
+ | Sequence l -> Cil_types.Block (build_block ~loc ~ghost l)
+ | Ghost s -> Cil_types.Block (build_block ~loc ~ghost:true [s])
+
+ and build_stmt ~loc ~ghost = function
+ | CilStmt s -> s
+ | Ghost s -> build_stmt ~loc ~ghost:true s
+ | stmt -> Cil.mkStmt ~ghost (build_stmtkind ~loc ~ghost stmt)
+
+ and build_block ~loc ~ghost l =
+ let bstmts = List.map (build_stmt ~ghost ~loc) (flatten_sequences l) in
+ Cil.mkBlock bstmts
+
+ (* Export *)
+
+ let cil_instr ~loc i = build_instr ~loc (harden_instr i)
+ let cil_stmtkind ~loc s = build_stmtkind ~loc ~ghost:false (harden_stmt s)
+ let cil_stmt ~loc s = build_stmt ~loc ~ghost:false (harden_stmt s)
+
+
+ (* Operators *)
+
+ let (:=) = assign
+ let (+=) lv e = assign lv (add lv e)
+ let (-=) lv e = assign lv (sub lv e)
+end
+
+
+(* --- Stateful builder --- *)
+
+let dkey = Kernel.register_category "cil-builder"
+
+exception WrongContext of string
+
+module type T =
+sig
+ val loc : Cil_types.location
+end
+
+module Stateful (Location : T) =
+struct
+ include Exp
+
+ type stmt =
+ | Label of Cil_types.label
+ | CilStmt of Cil_types.stmt
+ | CilStmtkind of Cil_types.stmtkind
+ | CilInstr of Cil_types.instr
+
+ type scope =
+ {
+ scope_type: scope_type;
+ ghost: bool;
+ mutable stmts: stmt list; (* In reverse order *)
+ mutable vars: Cil_types.varinfo list; (* In reverse order *)
+ }
+ and scope_type =
+ | Block
+ | IfThen of {ifthen_exp: Cil_types.exp}
+ | IfThenElse of {ifthenelse_exp: Cil_types.exp; then_block: Cil_types.block}
+ | Switch of {switch_exp: Cil_types.exp}
+ | Function of {fundec: Cil_types.fundec}
+
+
+ let loc = Location.loc
+
+
+ (* Conversion to Cil *)
+
+ let build_instr_list l =
+ let rev_build_one acc = function
+ | Label _ | CilStmt _ | CilStmtkind _ ->
+ raise (WrongContext "not convertible to instr")
+ | CilInstr instr -> instr :: acc
+ in
+ List.fold_left rev_build_one [] l
+
+ let build_stmt_list ~ghost l =
+ let rev_build_one acc = function
+ | Label l ->
+ begin match acc with
+ | [] -> (* No generated statement to attach the label to *)
+ let stmt = Cil.mkEmptyStmt ~ghost ~loc () in
+ stmt.Cil_types.labels <- [l];
+ stmt :: acc
+ | stmt :: _ -> (* There is a statement to attach the label to *)
+ stmt.Cil_types.labels <- l :: stmt.Cil_types.labels;
+ acc
+ end
+ | CilStmt stmt ->
+ stmt :: acc
+ | CilStmtkind sk ->
+ Cil.mkStmt ~ghost sk :: acc
+ | CilInstr instr ->
+ Cil.mkStmt ~ghost (Cil_types.Instr instr) :: acc
+ in
+ List.fold_left rev_build_one [] l
+
+ let build_block b =
+ let block = Cil.mkBlock (build_stmt_list ~ghost:b.ghost b.stmts) in
+ block.Cil_types.blocals <- List.rev b.vars;
+ block
+
+ let build_stmtkind b =
+ let block = build_block b in
+ match b.scope_type with
+ | Block ->
+ Cil_types.Block block
+ | IfThen { ifthen_exp } ->
+ Cil_types.If (ifthen_exp, block, Cil.mkBlock [], loc)
+ | IfThenElse { ifthenelse_exp; then_block } ->
+ Cil_types.If (ifthenelse_exp, then_block, block, loc)
+ | Switch { switch_exp } ->
+ let open Cil_types in
+ (* Cases are only allowed in the current block by the case function *)
+ let contains_case stmt =
+ List.exists (function Case _ -> true | _ -> false) stmt.labels
+ in
+ let case_stmts = List.filter contains_case block.bstmts in
+ Cil_types.Switch (switch_exp, block, case_stmts , loc)
+ | Function _ ->
+ raise (WrongContext "not convertible to stmtkind")
+
+
+ (* State management *)
+
+ let owner: Cil_types.fundec option ref = ref None
+
+ let reset_owner () =
+ owner := None
+
+ let set_owner o =
+ if Option.is_some !owner then
+ raise (WrongContext "already in a function");
+ owner := Some o
+
+ let get_owner () =
+ match !owner with
+ | None -> raise (WrongContext "function context not set")
+ | Some fundec -> fundec
+
+
+ let stack : scope list ref = ref []
+
+ let pretty_stack fmt =
+ let pretty_stack_type fmt b =
+ match b.scope_type with
+ | Block -> Format.pp_print_string fmt "block"
+ | IfThen _ -> Format.pp_print_string fmt "if-then"
+ | IfThenElse _ -> Format.pp_print_string fmt "if-then-else"
+ | Switch _ -> Format.pp_print_string fmt "switch"
+ | Function _ -> Format.pp_print_string fmt "function"
+ in
+ Pretty_utils.pp_list ~pre:"[@[" ~sep:";@," ~last:"@]]"
+ pretty_stack_type fmt !stack
+
+ let check_empty () =
+ if !stack <> [] then
+ raise (WrongContext "some contextes have not been closed")
+
+ let check_not_empty () =
+ if !stack = [] then
+ raise (WrongContext "only a finish_* function can close all contextes")
+
+ let top () =
+ match !stack with
+ | [] -> raise (WrongContext "not in an opened context")
+ | state :: _ -> state
+
+ let push state =
+ let parent_ghost = match !stack with
+ | [] -> false
+ | s :: _ -> s.ghost
+ in
+ stack := { state with ghost = parent_ghost || state.ghost } :: !stack;
+ Kernel.debug ~dkey "push onto %t" pretty_stack
+
+ let pop () =
+ Kernel.debug ~dkey "pop from %t" pretty_stack;
+ match !stack with
+ | [] -> raise (WrongContext "not in an opened context")
+ | hd :: tail ->
+ stack := tail;
+ hd
+
+ let finish () =
+ reset_owner ();
+ match !stack with
+ | [] -> raise (WrongContext "not in an opened context")
+ | [b] -> b
+ | _ :: _ :: _ -> raise (WrongContext "all contextes have not been closed")
+
+ let append_stmt b s =
+ b.stmts <- s :: b.stmts
+
+ let append_instr b i =
+ append_stmt b (CilInstr i)
+
+ let append_local v =
+ let fundec = get_owner () and b = top () in
+ fundec.Cil_types.slocals <- fundec.Cil_types.slocals @ [v];
+ b.vars <- v :: b.vars
+
+
+ (* Statements *)
+
+ let of_stmt s =
+ let b = top () in
+ append_stmt b (CilStmt s)
+
+ let of_stmts l =
+ List.iter of_stmt l
+
+ let of_stmtkind sk =
+ let b = top () in
+ append_stmt b (CilStmtkind sk)
+
+ let break () =
+ of_stmtkind (Cil_types.Break loc)
+
+ let return exp =
+ of_stmtkind (Cil_types.Return (cil_exp_opt ~loc exp, loc))
+
+
+ (* Blocks *)
+
+ let new_block ?(ghost=false) scope_type = {
+ scope_type;
+ ghost;
+ stmts = [];
+ vars = [];
+ }
+
+ let extract_ifthen_block b =
+ match b.scope_type with
+ | IfThen {ifthen_exp} -> ifthen_exp
+ | _ -> raise (WrongContext "not in an opened if-then-else context")
+
+ let extract_switch_block b =
+ match b.scope_type with
+ | Switch {switch_exp} -> switch_exp
+ | _ -> raise (WrongContext "not in a opened switch context")
+
+ let extract_function_block b =
+ match b.scope_type with
+ | Function {fundec} -> fundec
+ | _ -> raise (WrongContext "not in a opened function context")
+
+ let open_function ?ghost ?vorig_name name =
+ check_empty ();
+ let vorig_name = Option.value ~default:name vorig_name in
+ let fundec = Cil.emptyFunction vorig_name in
+ fundec.svar.vdecl <- loc;
+ fundec.svar.vname <- name;
+ set_owner fundec;
+ push (new_block ?ghost (Function {fundec}));
+ `var fundec.Cil_types.svar
+
+ let open_block ?into ?ghost () =
+ Option.iter set_owner into;
+ push (new_block ?ghost Block)
+
+ let open_ghost ?into () =
+ open_block ?into ~ghost:true ()
+
+ let open_switch ?into exp =
+ Option.iter set_owner into;
+ let switch_exp = cil_exp ~loc exp in
+ push (new_block (Switch {switch_exp}))
+
+ let open_if ?into exp =
+ Option.iter set_owner into;
+ let ifthen_exp = cil_exp ~loc exp in
+ push (new_block (IfThen {ifthen_exp}))
+
+ let open_else () =
+ let b = pop () in
+ let ifthenelse_exp = extract_ifthen_block b in
+ let then_block = build_block b in
+ push (new_block (IfThenElse {ifthenelse_exp; then_block}))
+
+ let close () =
+ let above = pop () in
+ check_not_empty ();
+ of_stmtkind (build_stmtkind above) (* add the block to the parent *)
+
+ let finish_block () =
+ let b = finish () in
+ match build_stmtkind b with
+ | Cil_types.Block b -> b
+ | _ -> raise (WrongContext "not in an opened simple block context")
+
+ let finish_instr_list ?scope () =
+ let b = finish () in
+ begin match scope, b.vars with
+ | None, [] -> () (* Nothing to do *)
+ | Some block, vars ->
+ block.Cil_types.blocals <- List.rev vars @ block.Cil_types.blocals
+ | None, _ :: _ ->
+ raise (WrongContext "a scope must be provided to insert local variables")
+ end;
+ build_instr_list b.stmts
+
+ let finish_stmt () =
+ let b = finish () in
+ Cil.mkStmt ~ghost:b.ghost (build_stmtkind b)
+
+ let finish_function ?(register=true) () =
+ let b = finish () in
+ let fundec = extract_function_block b in
+ let open Cil_types in
+ let vi = fundec.svar and spec = fundec.sspec in
+ fundec.sbody <- build_block b;
+ vi.vdefined <- true;
+ vi.vghost <- b.ghost;
+ if register then begin
+ Globals.Functions.replace_by_definition spec fundec loc;
+ let keepSwitch = Kernel.KeepSwitch.get () in
+ Cfg.prepareCFG ~keepSwitch fundec;
+ Cfg.cfgFun fundec;
+ end;
+ GFun (fundec,loc)
+
+ let finish_declaration ?(register=true) () =
+ let b = finish () in
+ let fundec = extract_function_block b in
+ let open Cil_types in
+ let vi = fundec.svar and spec = fundec.sspec in
+ if b.stmts <> [] then
+ raise (WrongContext "there must not be any built statements");
+ vi.vdefined <- false;
+ vi.vghost <- b.ghost;
+ if register then begin
+ Globals.Functions.replace_by_declaration spec vi loc;
+ end;
+ GFunDecl (spec, vi, loc)
+
+ let case exp =
+ let b = top () in
+ let _ = extract_switch_block b in
+ let label = Cil_types.Case (cil_exp ~loc exp, loc) in
+ append_stmt b (Label label)
+
+
+ (* Functions *)
+
+ let get_return_type () =
+ let fundec = get_owner () in
+ Cil.getReturnType fundec.svar.vtype
+
+ let set_return_type' ty =
+ let fundec = get_owner () in
+ Cil.setReturnType fundec ty
+
+ let set_return_type ty =
+ set_return_type' (cil_typ ty)
+
+ let add_attribute attr =
+ let fundec = get_owner () in
+ fundec.svar.vattr <- Cil.addAttribute attr fundec.svar.vattr
+
+ let add_new_attribute attr params =
+ add_attribute (Cil_types.Attr (attr, params))
+
+ let add_stdlib_generated () =
+ add_new_attribute "fc_stdlib_generated" []
+
+
+ (* Behaviors *)
+
+ let current_behavior () =
+ let b = top () in
+ let fundec = extract_function_block b in
+ match fundec.sspec.spec_behavior with
+ | [] ->
+ let default_behavior = Cil.mk_behavior () in
+ fundec.sspec.spec_behavior <- [default_behavior];
+ default_behavior
+ | bhv :: _ -> bhv
+
+ type source = [exp | `indirect of exp]
+
+ let indirect src =
+ match (src :> source ) with
+ | #exp as it | `indirect it -> `indirect it
+
+ let assigns dests sources =
+ let open Cil_types in
+ let b = current_behavior ()
+ and restyp = get_return_type () in
+ let map_source src =
+ match (src :> source) with
+ | #Exp.exp as e ->
+ cil_iterm ~loc ~restyp e
+ | `indirect e ->
+ let t = cil_term ~loc ~restyp e in
+ let t' = { t with term_name = "indirect" :: t.term_name } in
+ Logic_const.new_identified_term t'
+ and map_dest dst =
+ cil_iterm ~loc ~restyp dst
+ in
+ let dests' = List.map map_dest dests
+ and sources' = List.map map_source sources in
+ let previous = match b.b_assigns with
+ | WritesAny -> []
+ | Writes l -> l
+ and newones = List.map (fun dst -> dst, From sources') dests' in
+ b.b_assigns <- Writes (previous @ newones)
+
+ let requires pred =
+ let open Cil_types in
+ let b = current_behavior ()
+ and restyp = get_return_type () in
+ b.b_requires <- b.b_requires @ [cil_ipred ~loc ~restyp pred]
+
+ let ensures pred =
+ let open Cil_types in
+ let b = current_behavior ()
+ and restyp = get_return_type () in
+ b.b_post_cond <- b.b_post_cond @ [Normal, cil_ipred ~loc ~restyp pred]
+
+
+ (* Variables *)
+
+ let local' ?(ghost=false) ?init typ name =
+ let fundec = get_owner () and b = top () in
+ let ghost = ghost || b.ghost in
+ let v = Cil.makeLocalVar ~insert:false ~ghost ~loc fundec name typ in
+ begin match init with
+ | None -> ()
+ | Some init ->
+ let local_init = Cil_types.AssignInit (cil_init ~loc init) in
+ append_instr b (Cil_types.Local_init (v, local_init, loc));
+ v.vdefined <- true
+ end;
+ append_local v;
+ `var v
+
+ let local ?ghost ?init ty name =
+ let init = Option.map (values ty) init in
+ local' ?ghost ?init (cil_typ ty) name
+
+ let local_copy ?(ghost=false) ?(suffix="_tmp") (`var vi) =
+ let fundec = get_owner () and b = top () in
+ let ghost = ghost || b.ghost in
+ let v = Cil.copyVarinfo vi (vi.Cil_types.vname ^ suffix) in
+ v.vghost <- v.vghost || ghost;
+ Cil.refresh_local_name fundec v;
+ append_local v;
+ `var v
+
+ let parameter ?(ghost=false) ?(attributes=[]) typ name =
+ let fundec = get_owner () and b = top () in
+ let ghost = ghost || b.ghost in
+ let v = Cil.makeFormalVar ~ghost ~loc fundec name typ in
+ v.Cil_types.vattr <- attributes;
+ `var v
+
+
+ (* Instructions *)
+
+ let of_instr i =
+ let b = top () in
+ append_instr b i
+
+ let assign lval exp =
+ let lval' = cil_lval ~loc lval
+ and exp' = cil_exp ~loc exp in
+ of_instr (Cil_types.Set (lval', exp', loc))
+
+ let incr lval =
+ assign lval (add lval (of_int 1))
+
+ let call dest callee args =
+ let dest' = cil_lval_opt ~loc dest
+ and callee' = cil_exp ~loc callee
+ and args' = cil_exp_list ~loc args in
+ of_instr (Cil_types.Call (dest', callee', args', loc))
+
+ let pure exp =
+ let exp' = cil_exp ~loc exp in
+ let `var v = local' (Cil.typeOf exp') "tmp" ~init:(Exp.of_exp exp') in
+ v.vdescr <- Some (Format.asprintf "%a" !Cil.pp_exp_ref exp')
+
+ let skip () =
+ of_instr (Cil_types.Skip (loc))
+
+
+ (* Operators *)
+
+ let (:=) = assign
+ let (+=) lv e = assign lv (add lv e)
+ let (-=) lv e = assign lv (sub lv e)
+end
diff --git a/src/kernel_services/ast_building/cil_builder.mli b/src/kernel_services/ast_building/cil_builder.mli
new file mode 100644
index 0000000000000000000000000000000000000000..fdd07292cf63484ab2748422d578b182cfa5cc59
--- /dev/null
+++ b/src/kernel_services/ast_building/cil_builder.mli
@@ -0,0 +1,331 @@
+(**************************************************************************)
+(* *)
+(* This file is part of Frama-C. *)
+(* *)
+(* Copyright (C) 2007-2021 *)
+(* CEA (Commissariat à l'énergie atomique et aux énergies *)
+(* alternatives) *)
+(* *)
+(* you can redistribute it and/or modify it under the terms of the GNU *)
+(* Lesser General Public License as published by the Free Software *)
+(* Foundation, version 2.1. *)
+(* *)
+(* It is distributed in the hope that it will be useful, *)
+(* but WITHOUT ANY WARRANTY; without even the implied warranty of *)
+(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *)
+(* GNU Lesser General Public License for more details. *)
+(* *)
+(* See the GNU Lesser General Public License version 2.1 *)
+(* for more details (enclosed in the file licenses/LGPLv2.1). *)
+(* *)
+(**************************************************************************)
+
+(** This module is meant to build C or ACSL expressions in a unified way.
+ Compared to "classic" Cil functions it also avoid the necessity to provide
+ a location everywhere.
+*)
+
+module Type :
+sig
+ exception NotACType
+
+ type ('value,'shape) typ
+
+ (* Logic types *)
+ val of_ltyp : Cil_types.logic_type -> (unit,unit) typ
+ val integer : (unit,unit) typ
+ val real : (unit,unit) typ
+
+ (* C base types *)
+ val of_ctyp : Cil_types.typ -> ('v,'v) typ
+ val void : ('v,'v) typ
+ val bool : ('v,'v) typ
+ val char : ('v,'v) typ
+ val schar : ('v,'v) typ
+ val uchar : ('v,'v) typ
+ val int : ('v,'v) typ
+ val unit : ('v,'v) typ
+ val short : ('v,'v) typ
+ val ushort : ('v,'v) typ
+ val long : ('v,'v) typ
+ val ulong : ('v,'v) typ
+ val longlong : ('v,'v) typ
+ val ulonglong : ('v,'v) typ
+ val float : ('v,'v) typ
+ val double : ('v,'v) typ
+ val longdouble : ('v,'v) typ
+
+ val ptr : ('v,'s) typ -> ('v,'v) typ
+ val array : ?size:int -> ('v,'s) typ -> ('v,'s list) typ
+
+ (* Attributes *)
+ val attribute : ('v,'s) typ -> string -> Cil_types.attrparam list
+ -> ('v,'s) typ
+ val const : ('v,'s) typ -> ('v,'s) typ
+ val stdlib_generated : ('v,'s) typ -> ('v,'s) typ
+
+ (* Conversion *)
+ val cil_typ : ('v,'s) typ -> Cil_types.typ
+ val cil_logic_type : ('v,'s) typ -> Cil_types.logic_type
+end
+
+
+(* --- C & Logic expressions builder --- *)
+
+module Exp :
+sig
+ include module type of Type
+
+ type const'
+ type var'
+ type lval'
+ type exp'
+ type init'
+
+ type label
+ type const = [ `const of const' ]
+ type var = [ `var of var' ]
+ type lval = [ var | `lval of lval' ]
+ type exp = [ const | lval | `exp of exp' ]
+ type init = [ exp | `init of init']
+
+ val pretty : Format.formatter -> [init | `none] -> unit
+
+ val none : [> `none]
+
+ (* Labels *)
+
+ val here : label
+ val old : label
+ val pre : label
+ val post : label
+ val loop_entry : label
+ val loop_current : label
+ val program_init : label
+
+ (* Constants *)
+
+ val of_constant : Cil_types.constant -> [> const]
+ val of_int : int -> [> const]
+ val of_integer : Integer.t -> [> const]
+ val zero : [> const]
+ val one : [> const]
+
+ (* Lvalues *)
+
+ val var : Cil_types.varinfo -> [> var]
+ val of_lval : Cil_types.lval -> [> lval]
+
+ (* Expressions *)
+
+ exception EmptyList
+
+ val of_exp : Cil_types.exp -> [> exp]
+ val of_exp_copy : Cil_types.exp -> [> exp]
+ val unop : Cil_types.unop -> [< exp] -> [> exp]
+ val neg : [< exp] -> [> exp]
+ val lognot : [< exp] -> [> exp]
+ val bwnot : [< exp] -> [> exp]
+ val succ : [< exp] -> [> exp] (* e + 1 *)
+ val add_int : [< exp] -> int -> [> exp] (* e + i *)
+ val binop : Cil_types.binop -> [< exp] -> [< exp] -> [> exp]
+ val add : [< exp] -> [< exp] -> [> exp]
+ val sub : [< exp] -> [< exp] -> [> exp]
+ val mul : [< exp] -> [< exp] -> [> exp]
+ val div : [< exp] -> [< exp] -> [> exp]
+ val modulo : [< exp] -> [< exp] -> [> exp]
+ val shiftl : [< exp] -> [< exp] -> [> exp]
+ val shiftr : [< exp] -> [< exp] -> [> exp]
+ val lt : [< exp] -> [< exp] -> [> exp]
+ val gt : [< exp] -> [< exp] -> [> exp]
+ val le : [< exp] -> [< exp] -> [> exp]
+ val ge : [< exp] -> [< exp] -> [> exp]
+ val eq : [< exp] -> [< exp] -> [> exp]
+ val ne : [< exp] -> [< exp] -> [> exp]
+ val logor : [< exp] -> [< exp] -> [> exp]
+ val logand : [< exp] -> [< exp] -> [> exp]
+ val logor_list : [< exp] list -> exp
+ val logand_list : [< exp] list -> exp
+ val bwand : [< exp] -> [< exp] -> [> exp]
+ val bwor : [< exp] -> [< exp] -> [> exp]
+ val bwxor : [< exp] -> [< exp] -> [> exp]
+ val cast : ('v,'s) typ -> [< exp] -> [> exp]
+ val cast' : Cil_types.typ -> [< exp] -> [> exp]
+ val addr : [< lval] -> [> exp]
+ val mem : [< exp] -> [> lval]
+ val index : [< lval] -> [< exp] -> [> lval]
+ val field : [< lval] -> Cil_types.fieldinfo -> [> lval]
+ val fieldnamed : [< lval] -> string -> [> lval]
+
+ val result : [> lval]
+ val term : Cil_types.term -> [> exp]
+ val range : [< exp | `none] -> [< exp | `none] -> [> exp]
+ val whole : [> exp] (* Whole range, i.e. .. *)
+ val whole_right : [> exp] (* Whole range right side, i.e. 0.. *)
+ val app : Cil_types.logic_info -> label list -> [< exp] list -> [> exp]
+
+ val object_pointer : ?at:label -> [< exp] -> [> exp]
+ val valid : ?at:label -> [< exp] -> [> exp]
+ val valid_read : ?at:label -> [< exp] -> [> exp]
+ val initialized : ?at:label -> [< exp] -> [> exp]
+ val dangling : ?at:label -> [< exp] -> [> exp]
+ val allocable : ?at:label -> [< exp] -> [> exp]
+ val freeable : ?at:label -> [< exp] -> [> exp]
+ val fresh : label -> label -> [< exp] -> [< exp] -> [> exp]
+
+ val of_init : Cil_types.init -> [> init]
+ val compound : Cil_types.typ -> init list -> [> init]
+ val values : (init,'values) typ -> 'values -> init
+
+
+ (* Redefined operators *)
+
+ val (+) : [< exp] -> [< exp] -> [> exp]
+ val (-) : [< exp] -> [< exp] -> [> exp]
+ val ( * ) : [< exp] -> [< exp] -> [> exp]
+ val (/) : [< exp] -> [< exp] -> [> exp]
+ val (%) : [< exp] -> [< exp] -> [> exp]
+ val (<<) : [< exp] -> [< exp] -> [> exp]
+ val (>>) : [< exp] -> [< exp] -> [> exp]
+ val (<) : [< exp] -> [< exp] -> [> exp]
+ val (>) : [< exp] -> [< exp] -> [> exp]
+ val (<=) : [< exp] -> [< exp] -> [> exp]
+ val (>=) : [< exp] -> [< exp] -> [> exp]
+ val (==) : [< exp] -> [< exp] -> [> exp]
+ val (!=) : [< exp] -> [< exp] -> [> exp]
+ val (--) : [< exp] -> [< exp] -> [> exp]
+
+ (* Export CIL objects from built expressions *)
+
+ exception LogicInC of exp
+ exception CInLogic of exp
+ exception NotATerm of exp
+ exception NotAPredicate of exp
+ exception NotAFunction of Cil_types.logic_info
+ exception Typing_error of string
+
+ val cil_logic_label : label -> Cil_types.logic_label
+ val cil_constant : [< const] -> Cil_types.constant
+ val cil_varinfo : [< var] -> Cil_types.varinfo
+ val cil_lval : loc:Cil_types.location -> [< lval] -> Cil_types.lval
+ val cil_exp : loc:Cil_types.location -> [< exp] -> Cil_types.exp
+ val cil_term_lval : loc:Cil_types.location -> ?restyp:Cil_types.typ ->
+ [< lval] -> Cil_types.term_lval
+ val cil_term : loc:Cil_types.location -> ?restyp:Cil_types.typ ->
+ [< exp] -> Cil_types.term
+ val cil_iterm : loc:Cil_types.location -> ?restyp:Cil_types.typ ->
+ [< exp] -> Cil_types.identified_term
+ val cil_pred : loc:Cil_types.location -> ?restyp:Cil_types.typ ->
+ [< exp] -> Cil_types.predicate
+ val cil_ipred : loc:Cil_types.location -> ?restyp:Cil_types.typ ->
+ [< exp] -> Cil_types.identified_predicate
+ val cil_init : loc:Cil_types.location -> [< init] -> Cil_types.init
+
+ val cil_typeof : [< var] -> Cil_types.typ
+end
+
+
+(* --- Pure builder --- *)
+
+module Pure :
+sig
+ include module type of Exp
+
+ type instr'
+ type stmt'
+
+ type instr = [ `instr of instr' ]
+ type stmt = [ instr | `stmt of stmt' ]
+
+ (* Instructions *)
+ val of_instr : Cil_types.instr -> [> instr]
+ val skip : [> instr]
+ val assign : [< lval] -> [< exp] -> [> instr]
+ val incr : [< lval] -> [> instr]
+ val call : [< lval | `none] -> [< exp] -> [< exp] list -> [> instr]
+
+ (* Statements *)
+ val of_stmtkind : Cil_types.stmtkind -> [> stmt]
+ val of_stmt : Cil_types.stmt -> [> stmt]
+ val of_stmts : Cil_types.stmt list -> [> stmt]
+ val block : [< stmt] list -> [> stmt]
+ val ghost : [< stmt] -> [> stmt]
+
+ val cil_instr : loc:Cil_types.location -> instr -> Cil_types.instr
+ val cil_stmtkind : loc:Cil_types.location -> stmt -> Cil_types.stmtkind
+ val cil_stmt : loc:Cil_types.location -> stmt -> Cil_types.stmt
+
+ (* Operators *)
+ val (:=) : [< lval] -> [< exp] -> [> instr] (* assign *)
+ val (+=) : [< lval] -> [< exp] -> [> instr]
+ val (-=) : [< lval] -> [< exp] -> [> instr]
+end
+
+
+(* --- Stateful builder --- *)
+
+exception WrongContext of string
+
+module type T =
+sig
+ val loc : Cil_types.location
+end
+
+module Stateful (Location : T) :
+sig
+ include module type of Exp
+
+ (* Functions *)
+ val open_function : ?ghost:bool -> ?vorig_name:string -> string -> [> var]
+ val set_return_type : ('s,'v) typ -> unit
+ val set_return_type' : Cil_types.typ -> unit
+ val add_attribute : Cil_types.attribute -> unit
+ val add_new_attribute : string -> Cil_types.attrparam list -> unit
+ val add_stdlib_generated : unit -> unit
+ val finish_function : ?register:bool -> unit -> Cil_types.global
+ val finish_declaration : ?register:bool -> unit -> Cil_types.global
+
+ (* Behaviors *)
+ type source = [exp | `indirect of exp]
+ val indirect: [< source] -> [> source]
+ val assigns: [< exp] list -> [< exp | `indirect of [< exp]] list -> unit
+ val requires: [< exp] -> unit
+ val ensures: [< exp] -> unit
+
+ (* Statements *)
+ val of_stmtkind : Cil_types.stmtkind -> unit
+ val of_stmt : Cil_types.stmt -> unit
+ val of_stmts : Cil_types.stmt list -> unit
+ val open_block : ?into:Cil_types.fundec -> ?ghost:bool -> unit -> unit
+ val open_ghost : ?into:Cil_types.fundec -> unit -> unit
+ val open_switch : ?into:Cil_types.fundec -> [< exp] -> unit
+ val open_if : ?into:Cil_types.fundec -> [< exp] -> unit
+ val open_else : unit -> unit
+ val close : unit -> unit
+ val finish_block : unit -> Cil_types.block
+ val finish_instr_list : ?scope:Cil_types.block -> unit -> Cil_types.instr list
+ val finish_stmt : unit -> Cil_types.stmt
+ val case : [< exp] -> unit
+ val break : unit -> unit
+ val return : [< exp | `none] -> unit
+
+ (* Variables *)
+ val local : ?ghost:bool -> ?init:'v -> (init,'v) typ -> string -> [> var]
+ val local' : ?ghost:bool -> ?init:init -> Cil_types.typ -> string -> [> var]
+ val local_copy : ?ghost:bool -> ?suffix:string -> [< var] -> [> var]
+ val parameter : ?ghost:bool -> ?attributes:Cil_types.attributes ->
+ Cil_types.typ -> string -> [> var]
+
+ (* Instructions *)
+ val of_instr : Cil_types.instr -> unit
+ val skip : unit -> unit
+ val assign : [< lval] -> [< exp] -> unit
+ val incr : [< lval] -> unit
+ val call : [< lval | `none] -> [< exp] -> [< exp] list -> unit
+ val pure : [< exp ] -> unit
+
+ (* Operators *)
+ val (:=) : [< lval] -> [< exp] -> unit (* assign *)
+ val (+=) : [< lval] -> [< exp] -> unit
+ val (-=) : [< lval] -> [< exp] -> unit
+end
diff --git a/src/plugins/e-acsl/tests/builtin/oracle_ci/gen_strcmp.c b/src/plugins/e-acsl/tests/builtin/oracle_ci/gen_strcmp.c
index 3b280b583484d187bb68b50d7e24788ab0c7473a..ee5d632ef771e23467dfb6e520001caf93795f36 100644
--- a/src/plugins/e-acsl/tests/builtin/oracle_ci/gen_strcmp.c
+++ b/src/plugins/e-acsl/tests/builtin/oracle_ci/gen_strcmp.c
@@ -127,9 +127,9 @@ __inline static void fail_ncomp(int cond, char *fmt, int l, int r)
__e_acsl_store_block((void *)(__va_args),(size_t)16);
__e_acsl_full_init((void *)(& __va_args));
fprintf(stderr,(char const *)fmt,(void * const *)(__va_args));
- __e_acsl_delete_block((void *)(& __va_arg0));
- __e_acsl_delete_block((void *)(& __va_arg1));
__e_acsl_delete_block((void *)(__va_args));
+ __e_acsl_delete_block((void *)(& __va_arg1));
+ __e_acsl_delete_block((void *)(& __va_arg0));
}
__gen_e_acsl_abort();
}
diff --git a/src/plugins/e-acsl/tests/special/oracle_ci/gen_e-acsl-instrument.c b/src/plugins/e-acsl/tests/special/oracle_ci/gen_e-acsl-instrument.c
index 6a43cdb89269af79eb1d36f572a300dbb71dbd2b..c56ee16b78b3a36e0e91479b02110be6524b942e 100644
--- a/src/plugins/e-acsl/tests/special/oracle_ci/gen_e-acsl-instrument.c
+++ b/src/plugins/e-acsl/tests/special/oracle_ci/gen_e-acsl-instrument.c
@@ -120,8 +120,8 @@ int main(void)
__e_acsl_store_block((void *)(__va_args),(size_t)8);
__e_acsl_full_init((void *)(& __va_args));
tmp = vol(6,(void * const *)(__va_args));
- __e_acsl_delete_block((void *)(& __va_arg0));
__e_acsl_delete_block((void *)(__va_args));
+ __e_acsl_delete_block((void *)(& __va_arg0));
}
__e_acsl_delete_block((void *)(& y));
__e_acsl_delete_block((void *)(& x));
diff --git a/src/plugins/variadic/Makefile.in b/src/plugins/variadic/Makefile.in
index cd2531c7381dacebaf1137c1713a5056a41416b6..55c44a67d7fa4dec399f83f3a68b2be019f255d7 100644
--- a/src/plugins/variadic/Makefile.in
+++ b/src/plugins/variadic/Makefile.in
@@ -37,7 +37,7 @@ PLUGIN_DIR ?= .
PLUGIN_ENABLE := @ENABLE_VARIADIC@
PLUGIN_NAME := Variadic
PLUGIN_CMI := format_types va_types
-PLUGIN_CMO := options extends va_build environment replacements \
+PLUGIN_CMO := options extends environment replacements \
format_string format_pprint format_typer format_parser \
generic standard classify translate \
register
diff --git a/src/plugins/variadic/generic.ml b/src/plugins/variadic/generic.ml
index 556507ffe1fff4362f040a8fb8d7d4264190c233..56d847f4a86e13057df7f47a00081119cc6bf812 100644
--- a/src/plugins/variadic/generic.ml
+++ b/src/plugins/variadic/generic.ml
@@ -24,7 +24,7 @@ open Cil_types
open Options
module List = Extends.List
module Typ = Extends.Typ
-module Build = Va_build
+module Build = Cil_builder.Pure
(* Types of variadic parameter and argument *)
@@ -99,32 +99,30 @@ let translate_va_builtin caller inst =
in
let translate_va_arg () =
- let va_list, typ, lval = match args with
+ let va_list, ty, lv = match args with
| [{enode=Lval va_list};
- {enode=SizeOf typ};
- {enode=CastE(_, {enode=AddrOf lval})}] -> va_list, typ, lval
+ {enode=SizeOf ty};
+ {enode=CastE(_, {enode=AddrOf lv})}] -> va_list, ty, lv
| _ -> Self.fatal "Unexpected arguments to va_arg"
in
(* Check validity of type *)
- if Cil.isIntegralType typ then begin
- let promoted_type = Cil.integralPromotion typ in
- if promoted_type <> typ then
+ if Cil.isIntegralType ty then begin
+ let promoted_type = Cil.integralPromotion ty in
+ if promoted_type <> ty then
Self.warning ~current:true
"Wrong type argument in va_start: %a is promoted to %a when used \
in the variadic part of the arguments. (You should pass %a to \
va_start)"
- Printer.pp_typ typ
+ Printer.pp_typ ty
Printer.pp_typ promoted_type
Printer.pp_typ promoted_type
end;
(* Build the replacing instruction *)
- let mk_lval_exp lval = Cil.new_exp ~loc (Lval lval) in
- let mk_mem exp = mk_lval_exp (Cil.mkMem ~addr:exp ~off:NoOffset) in
- let mk_cast exp typ = Cil.mkCast ~force:false ~newt:typ exp in
- let src = mk_mem (mk_cast (mk_mem (mk_lval_exp va_list)) (TPtr (typ,[])))
- in
- [ Set (lval, src, loc);
- Set (va_list, Cil.increm (mk_lval_exp va_list) 1, loc) ]
+ let va_list, ty, lv = Build.(of_lval va_list, of_ctyp ty, of_lval lv) in
+ List.map (Build.cil_instr ~loc) Build.([
+ lv := mem (cast (ptr ty) (mem va_list));
+ va_list += of_int 1
+ ])
in
begin match vi.vname with
@@ -139,7 +137,6 @@ let translate_va_builtin caller inst =
(* Translation of calls to variadic functions *)
let translate_call ~fundec ~ghost block loc mk_call callee pars =
-
(* Log translation *)
Self.result ~current:true ~level:2
"Generic translation of call to variadic function.";
@@ -151,29 +148,27 @@ let translate_call ~fundec ~ghost block loc mk_call callee pars =
let variadic_size = (List.length r_exps) - (List.length g_params) in
let v_exps, g_exps = List.break variadic_size r_exps in
+ (* Start build *)
+ let module Build = Cil_builder.Stateful (struct let loc = loc end) in
+ Build.open_block ~into:fundec ~ghost ();
+
(* Create temporary variables to hold parameters *)
- let add_var i exp =
- let typ = Cil.typeOf exp
- and name = "__va_arg" ^ string_of_int i in
- let res = Cil.makeLocalVar ~ghost fundec ~scope:block name typ in
- res.vdefined <- true;
- res
+ let add_var i e =
+ let name = "__va_arg" ^ string_of_int i in
+ Build.(local' (Cil.typeOf e) name ~init:(of_exp e))
in
let vis = List.mapi add_var v_exps in
- (* Assign parameters to these *)
- let instrs = List.map2 (Build.vi_init ~loc) vis v_exps in
-
(* Build an array to store addresses *)
- let addrs = List.map Cil.mkAddrOfVi vis in
- let vargs, assigns = Build.array_init ~loc fundec ~ghost block
- "__va_args" Cil.voidPtrType addrs
+ let init = match vis with (* C standard forbids arrays of size 0 *)
+ | [] -> [Build.of_init (Cil.makeZeroInit ~loc Cil.voidPtrType)]
+ | l -> List.map Build.addr l
in
- let instrs = instrs @ [assigns] in
+ let ty = Build.(array (ptr void) ~size:(List.length init)) in
+ let vargs = Build.(local ty "__va_args" ~init) in
(* Translate the call *)
- let exp_vargs = Cil.mkAddrOrStartOf ~loc (Cil.var vargs) in
- let new_arg = Cil.mkCast ~force:false ~newt:(vpar_typ []) exp_vargs in
- let new_args = s_exps @ [new_arg] @ g_exps in
- let call = mk_call callee new_args in
- instrs @ [call]
+ let new_arg = Build.(cil_exp ~loc (cast' (vpar_typ []) (addr vargs))) in
+ let new_args = (s_exps @ [new_arg] @ g_exps) in
+ Build.of_instr (mk_call callee new_args);
+ Build.finish_instr_list ~scope:block ()
diff --git a/src/plugins/variadic/standard.ml b/src/plugins/variadic/standard.ml
index b454f7f11e4cd911d76231fe36be3c7c9652f246..6ca8ff90c6eddbe2dfd253b50df02acb309b8b15 100644
--- a/src/plugins/variadic/standard.ml
+++ b/src/plugins/variadic/standard.ml
@@ -25,11 +25,6 @@ open Va_types
open Options
module List = Extends.List
module Typ = Extends.Typ
-module Build = Va_build
-
-
-let params_types params =
- List.map (fun (_,typ,_) -> typ) params
let pp_prototype name fmt tparams =
Format.fprintf fmt "%s(%a)"
@@ -177,8 +172,8 @@ let find_null exp_list =
List.ifind (fun e -> Cil.isZero (Cil.constFold false e)) exp_list
-let aggregator_call
- ~fundec ~ghost {a_target; a_pos; a_type; a_param} scope loc mk_call vf args =
+let aggregator_call ~fundec ~ghost aggregator scope loc mk_call vf args =
+ let {a_target; a_pos; a_type; a_param} = aggregator in
let name = vf.vf_decl.vorig_name
and tparams = Typ.params_types a_target.vtype
and pname, ptyp = a_param in
@@ -220,15 +215,21 @@ let aggregator_call
"Translating call to %s to a call to %s."
name a_target.vorig_name;
let pname = if pname = "" then "param" else pname in
- let vaggr, assigns =
- Build.array_init ~loc fundec ~ghost scope pname ptyp args_middle
+
+ let module Build = Cil_builder.Stateful (struct let loc = loc end) in
+ Build.open_block ~into:fundec ~ghost ();
+ let init = match args_middle with (* C standard forbids arrays of size 0 *)
+ | [] -> [Build.of_init (Cil.makeZeroInit ~loc ptyp)]
+ | l -> List.map Build.of_exp l
in
- let new_arg = Cil.mkAddrOrStartOf ~loc (Cil.var vaggr) in
- let new_args = args_left @ [new_arg] @ args_right in
+ let size = List.length init in
+ let vaggr = Build.(local (array ~size (of_ctyp ptyp)) pname ~init) in
+ let new_args = args_left @ [Build.(cil_exp ~loc (addr vaggr))] @ args_right in
let new_args,_ = match_args tparams new_args in
- let call = mk_call (Cil.evar ~loc a_target) new_args in
- let reads = List.map (Cil.mkPureExprInstr ~fundec ~scope ~loc) unused_args in
- assigns :: reads @ [call]
+ Build.(List.iter pure (List.map of_exp unused_args));
+ Build.of_instr (mk_call (Cil.evar ~loc a_target) new_args);
+ Build.finish_instr_list ~scope ()
+
(* ************************************************************************ *)
(* Overloads calls *)
@@ -326,23 +327,23 @@ let find_global env name =
let find_predicate name =
match Logic_env.find_all_logic_functions name with
- | f :: _q -> Some f (* TODO: should we warn in case of overloading? *)
+ | f :: _q -> f (* TODO: should we warn in case of overloading? *)
| [] ->
Self.warning ~once:true
"Unable to locate ACSL predicate %s which should be in the Frama-C LibC. \
Correct specifications can't be generated."
name;
- None
+ raise Not_found
let find_field env structname fieldname =
try
let compinfo = Environment.find_struct env structname in
- Some (Cil.getCompField compinfo fieldname)
+ Cil.getCompField compinfo fieldname
with Not_found ->
Self.warning ~once:true
"Unable to locate %s field %s."
structname fieldname;
- None
+ raise Not_found
let find_predicate_by_width typ narrow_name wide_name =
match Cil.unrollTypeDeep typ with
@@ -357,189 +358,158 @@ let find_predicate_by_width typ narrow_name wide_name =
Self.warning ~current:true
"expected single/wide character pointer type, got %a (%a, unrolled %a)"
Printer.pp_typ typ Cil_types_debug.pp_typ typ Cil_types_debug.pp_typ (Cil.unrollTypeDeep typ);
- None
+ raise Not_found
-let build_fun_spec env loc vf format_fun tvparams formals =
- let open Format_types in
- let _ = () in
- let fixed_params_count = Typ.params_count vf.vf_original_type in
- let sformals, vformals = List.break fixed_params_count formals in
- let here = Logic_const.here_label in
+let valid_read_string typ =
+ find_predicate_by_width typ "valid_read_string" "valid_read_wstring"
- (* Spec *)
- let sources = ref []
- and dests = ref []
- and requires = ref []
- and ensures = ref [] in
- let iterm lval =
- Logic_const.new_identified_term (Build.tlval ~loc lval)
- and insert x t =
- t := x :: !t
+let valid_read_nstring typ =
+ find_predicate_by_width typ "valid_read_nstring" "valid_read_nwstring"
+
+let format_length typ =
+ find_predicate_by_width typ "format_length" "wformat_length"
+
+
+let build_specialized_fun env vf format_fun tvparams =
+ let open Format_types in
+ let module Build =
+ Cil_builder.Stateful (struct let loc = vf.vf_decl.vdecl end)
in
- let insert_source ?(indirect=false) lval =
- let itlval = iterm lval in
- let it_content = if indirect then
- { itlval.it_content with
- term_name = "indirect" :: itlval.it_content.term_name }
- else itlval.it_content
+
+ (* Choose function name *)
+ let name = vf.vf_decl.vorig_name in
+ vf.vf_specialization_count <- vf.vf_specialization_count + 1;
+ let new_name = name ^ "_va_" ^ (string_of_int vf.vf_specialization_count) in
+
+ (* Start building the function *)
+ let funvar = Build.open_function new_name in
+
+ (* Set function return type and attributes *)
+ let ret_typ, params, _, attrs = Cil.splitFunctionType vf.vf_original_type in
+ Build.set_return_type' ret_typ;
+ List.iter Build.add_attribute attrs;
+ Build.add_stdlib_generated ();
+
+ (* Add parameters *)
+ let add_static_param (name,typ,attributes) =
+ Build.parameter ~attributes typ name
+ and add_variadic_param i (typ,_dir) =
+ let typ = if Cil.isIntegralType typ then
+ Cil.integralPromotion typ
+ else
+ typ
in
- let itlval = { itlval with Cil_types.it_content } in
- insert itlval sources
- and insert_dest lval =
- insert (iterm lval) dests
- and insert_require pred =
- insert (Logic_const.new_predicate pred) requires
- and insert_ensure pred =
- insert (Normal, Logic_const.new_predicate pred) ensures
+ Build.parameter typ ("param" ^ string_of_int i)
+ in
+ let sformals = List.map add_static_param (Option.get params)
+ and vformals = List.mapi add_variadic_param tvparams
in
- let add_lval ~indirect (lval,dir) =
- (* Add the lval to the list of sources/dests *)
- begin match dir with
- | (`ArgIn | `ArgInArray _) -> insert_source ~indirect lval
- | (`ArgOut | `ArgOutArray) -> insert_dest lval
- | `ArgInOut -> insert_source ~indirect lval; insert_dest lval
- end
+
+
+ (* Spec *)
+ let sources = ref [] and dests = ref [] in
+ let add_source ?(indirect=false) s =
+ let s = (s :> Build.source) in
+ sources := (if indirect then Build.indirect s else s) :: !sources
+ and add_dest d =
+ dests := (d :> Build.exp) :: !dests
in
- let add_var ?pos (vi,dir) =
+ (* Add the lval to the list of sources/dests *)
+ let add_lval ~indirect lval = function
+ | (`ArgIn | `ArgInArray _) -> add_source ~indirect lval
+ | (`ArgOut | `ArgOutArray) -> add_dest lval
+ | `ArgInOut -> add_source ~indirect lval; add_dest lval
+ in
+ let add_var ?pos ~indirect (v : Build.var) dir =
+ let ty = Build.cil_typeof v in
(* Use the appropriate logical lval *)
let lval = match dir with
- | `ArgIn -> Build.lvar vi
- | (`ArgInArray _ | `ArgOutArray) -> Build.trange_from_vi ~loc vi
- | (`ArgOut | `ArgInOut) -> Build.tvarmem ~loc vi
+ | `ArgIn -> (v :> Build.lval)
+ | (`ArgInArray _ | `ArgOutArray) -> Build.(index v whole_right)
+ | (`ArgOut | `ArgInOut) -> Build.(mem v)
in
+ add_lval ~indirect lval dir;
(* Build requires/ensures *)
- let term = Build.tvar ~loc vi in
- begin match dir with
+ try match dir with
| `ArgInArray None ->
- let pred =
- find_predicate_by_width vi.vtype "valid_read_string" "valid_read_wstring"
- in
- begin match pred with
- | Some logic_info ->
- let labels = List.map (fun _ -> here) logic_info.l_labels in
- let p = Logic_const.papp ~loc (logic_info, labels, [term]) in
- insert_require p
- | None -> ()
- end
+ Build.(requires (app (valid_read_string ty) [here] [v]))
| `ArgInArray (Some precision) ->
- assert (pos <> None);
- let pred =
- find_predicate_by_width vi.vtype "valid_read_nstring" "valid_read_nwstring"
+ let nterm = match precision with
+ | PStar ->
+ let size_arg = List.nth vformals (Option.get pos - 1) in
+ Build.(cast integer size_arg)
+ | PInt n ->
+ Build.of_int n
in
- begin match pred with
- | Some logic_info ->
- let labels = List.map (fun _ -> here) logic_info.l_labels in
- let nterm = match precision with
- | PStar ->
- let n_vi = List.nth vformals (Option.get pos) in
- Logic_utils.numeric_coerce Linteger (Build.tvar ~loc n_vi)
- | PInt n -> Cil.lconstant ~loc (Integer.of_int n)
- in
- let p = Logic_const.papp ~loc (logic_info, labels, [term; nterm]) in
- insert_require p
- | None -> ()
- end
+ Build.(requires (app (valid_read_nstring ty) [here] [(v :> Build.exp) ; nterm]))
| `ArgOut ->
- insert_require (Logic_const.pvalid ~loc (here,term));
- insert_ensure (Logic_const.pinitialized ~loc (here,term))
+ Build.(requires (valid v));
+ Build.(ensures (initialized v))
| _ -> ()
- end;
- (* Cil.hasAttribute "const" *)
- add_lval (lval,dir)
- in
- let make_indirect iterm =
- (* Add "indirect" to an identified term, if it isn't already *)
- if List.mem "indirect" iterm.it_content.term_name then iterm
- else
- let it_content =
- { iterm.it_content with
- term_name = "indirect" :: iterm.it_content.term_name }
- in
- { iterm with it_content }
+ with Not_found -> () (* Predicate not found *)
in
+
(* Build variadic parameter source/dest list *)
- let dirs = List.map snd tvparams in
- let l = List.combine vformals dirs in
- let pos = ref (-1) in
- List.iter (incr pos; add_var ~indirect:false ~pos:!pos) l;
+ let l = List.combine vformals tvparams in
+ List.iteri (fun pos (v,(_,dir)) -> add_var ~indirect:false ~pos v dir) l;
(* Add format source and additional parameters *)
- let fmt_vi = List.nth sformals format_fun.f_format_pos in
- add_var ~indirect:true (fmt_vi, `ArgInArray None);
+ let fmt = List.nth sformals format_fun.f_format_pos in
+ add_var ~indirect:true fmt (`ArgInArray None);
(* Add buffer source/dest *)
- let add_stream vi =
+ let add_stream v =
(* assigns stream->__fc_FILE_data
\from stream->__fc_FILE_data, __fc_FILE_id *)
- begin match find_field env "__fc_FILE" "__fc_FILE_data" with
- | Some fieldinfo ->
- let varfield = Build.tvarfield ~loc vi fieldinfo in
- add_lval ~indirect:false (varfield, `ArgInOut)
- | None ->
- add_var ~indirect:false (vi, `ArgInOut)
- end;
- begin match find_field env "__fc_FILE" "__fc_FILE_id" with
- | Some fieldinfo ->
- let varfield = Build.tvarfield ~loc vi fieldinfo in
- add_lval ~indirect:true (varfield, `ArgIn)
- | None -> ()
- end
+ try
+ let f_data = find_field env "__fc_FILE" "__fc_FILE_data"
+ and f_id = find_field env "__fc_FILE" "__fc_FILE_id" in
+ add_lval ~indirect:false Build.(field v f_data) `ArgInOut;
+ add_lval ~indirect:true Build.(field v f_id) `ArgIn
+ with Not_found ->
+ add_var ~indirect:false v `ArgInOut
in
(* Add a bounded buffer *)
- let add_buffer vi_buffer vi_size =
- add_var ~indirect:true (vi_size, `ArgIn);
+ let add_buffer buffer size =
+ add_var ~indirect:true size `ArgIn;
(* this is an snprintf-like function; compute and add its precondition:
\valid(s + (0..n-1)) || \valid(s + (0..format_length(format)-1)) *)
- let make_valid_range tvalid_length =
- let tvar = Build.tvar ~loc vi_buffer
- and tmin = Build.tzero ~loc
- and tmax = Build.tminus ~loc tvalid_length (Build.tone ~loc) in
- let toffs = Build.trange ~loc (Some tmin) (Some tmax) in
- let term = Build.tbinop ~loc PlusPI tvar toffs in
- Logic_const.pvalid ~loc (here, term)
- in
- let size_var = Build.tvar ~loc vi_size in
- let left_pred = make_valid_range size_var in
- let pred =
- find_predicate_by_width vi_buffer.vtype "format_length" "wformat_length"
+ let valid_range length =
+ Build.(valid (buffer + (zero -- (length - one))))
in
- match pred with
- | Some format_length ->
- let labels = List.map (fun _ -> here) format_length.l_labels in
- let fmt_var = Build.tvar ~loc fmt_vi in
- let flen_app =
- try Build.tapp ~loc format_length labels [fmt_var]
- with Build.NotAFunction ->
- Self.abort ~current:true
- "%a should be a logic function, not a predicate"
- Printer.pp_logic_var format_length.l_var_info
- in
- let right_pred = make_valid_range flen_app in
- let p = Logic_const.por ~loc (left_pred, right_pred) in
- insert_require p
- | None -> insert_require left_pred
+ let left_pred = valid_range size in
+ try
+ let flen = format_length (Build.cil_typeof buffer) in
+ let right_pred = Build.(valid_range (app flen [here] [fmt])) in
+ Build.(requires (logor left_pred right_pred))
+ with
+ | Not_found -> Build.requires left_pred
+ | Build.NotAFunction li ->
+ Self.abort ~current:true
+ "%a should be a logic function, not a predicate"
+ Printer.pp_logic_var li.l_var_info
in
begin match format_fun.f_buffer, format_fun.f_kind with
| StdIO, ScanfLike ->
begin match find_global env "__fc_stdin" with
- | Some vi -> add_stream vi
+ | Some vi -> add_stream (Build.var vi)
| None -> ()
end
| StdIO, PrintfLike ->
begin match find_global env "__fc_stdout" with
- | Some vi -> add_stream vi
+ | Some vi -> add_stream (Build.var vi)
| None -> ()
end
| Arg (i, _), ScanfLike ->
- add_var ~indirect:true (List.nth sformals i, `ArgInArray None)
+ add_var ~indirect:true (List.nth sformals i) (`ArgInArray None)
| Arg (i, size_pos), PrintfLike ->
- add_var ~indirect:true (List.nth sformals i, `ArgOutArray);
+ add_var ~indirect:true (List.nth sformals i) (`ArgOutArray);
begin match size_pos with
| Some n ->
add_buffer (List.nth sformals i) (List.nth sformals n)
@@ -549,40 +519,24 @@ let build_fun_spec env loc vf format_fun tvparams formals =
add_stream (List.nth sformals i)
| File i, _ ->
let file = List.nth sformals i in
- add_var ~indirect:true (file, `ArgIn);
+ add_var ~indirect:true file `ArgIn;
| Syslog, _ -> ()
end;
- (* Build the assigns clause (without \result, for now; it will be added
- separately) *)
- let froms = List.map (fun iterm -> iterm, From !sources) !dests in
-
- (* Add return value dest: it is different from above since it is _indirectly_
- assigned from all sources *)
- let rettyp = Cil.getReturnType vf.vf_decl.vtype in
- let froms_for_result =
- if Cil.isVoidType rettyp then []
- else
- [iterm (Build.tresult rettyp),
- From (List.map make_indirect !sources)]
- in
- let assigns = Writes (froms_for_result @ froms) in
+ (* assign \result \from indirect:sources *)
+ if not (Cil.isVoidType ret_typ) then
+ Build.(assigns [result] (List.map indirect !sources));
+ (* assigns dests \from sources *)
+ Build.assigns !dests !sources;
(* Build the default behaviour *)
- let bhv = Cil.mk_behavior ~assigns
- ~requires:!requires ~post_cond:!ensures () in
- { (Cil.empty_funspec ()) with spec_behavior = [bhv] }
+ let glob = Build.finish_declaration ~register:false () in
+ glob, Build.cil_varinfo funvar
(* --- Call translation --- *)
let format_fun_call ~fundec env format_fun scope loc mk_call vf args =
- let name = vf.vf_decl.vorig_name
- and params = Typ.params vf.vf_decl.vtype in
- (* Remove the va_param parameter added during the declaration visit *)
- let fixed_params_count = Typ.params_count vf.vf_original_type in
- let sparams = List.take fixed_params_count params in
-
(* Extract the format if possible *)
let format =
try
@@ -591,7 +545,7 @@ let format_fun_call ~fundec env format_fun scope loc mk_call vf args =
| None ->
Self.warning ~current:true
"Call to function %s with non-static format argument:@ \
- no specification will be generated." name;
+ no specification will be generated." vf.vf_decl.vorig_name;
raise Translate_call_exn (* No syntactic hint *)
| Some s -> Format_parser.parse_format format_fun.f_kind s
with
@@ -612,29 +566,9 @@ let format_fun_call ~fundec env format_fun scope loc mk_call vf args =
type_name;
raise Translate_call_exn
in
- let new_param i (typ,_dir) =
- let typ = if Cil.isIntegralType typ then
- Cil.integralPromotion typ
- else
- typ
- in
- "param" ^ string_of_int i, typ, []
- in
- let vparams = List.mapi new_param tvparams in
- let new_params = sparams @ vparams in
(* Create the new callee *)
- vf.vf_specialization_count <- vf.vf_specialization_count + 1;
- let ret_typ, _, _, attributes = Cil.splitFunctionType vf.vf_decl.vtype in
- let new_callee_typ = TFun (ret_typ, Some new_params, false, attributes)
- and new_name = name ^ "_va_" ^ (string_of_int vf.vf_specialization_count)
- and mk_spec formals = build_fun_spec env loc vf format_fun tvparams formals
- in
- let new_callee, glob =
- Build.function_declaration ~vattr:[Attr ("fc_stdlib_generated", [])]
- ~loc:vf.vf_decl.vdecl name new_callee_typ mk_spec
- in
- new_callee.vname <- new_name;
+ let glob, new_callee = build_specialized_fun env vf format_fun tvparams in
new_globals := glob :: !new_globals;
(* Store the translation *)
@@ -643,6 +577,6 @@ let format_fun_call ~fundec env format_fun scope loc mk_call vf args =
(* Translate the call *)
Self.result ~current:true ~level:2
"Translating call to %s to a call to the specialized version %s."
- name new_callee.vname;
- let tparams = params_types new_params in
+ vf.vf_decl.vorig_name new_callee.vname;
+ let tparams = Typ.params_types new_callee.vtype in
match_call ~loc ~fundec scope mk_call new_callee tparams args
diff --git a/src/plugins/variadic/tests/known/oracle/printf.res.oracle b/src/plugins/variadic/tests/known/oracle/printf.res.oracle
index b27f1f19a86a752ba8ffd43518ad3318c4b1483d..591d9eb02fe97ba608a2aec6af1a5cce8506d1d4 100644
--- a/src/plugins/variadic/tests/known/oracle/printf.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/printf.res.oracle
@@ -179,9 +179,9 @@
*/
int printf_va_1(char const * restrict format);
-/*@ requires valid_read_string(format);
+/*@ requires valid_read_string(param0);
requires \valid(param1);
- requires valid_read_string(param0);
+ requires valid_read_string(format);
ensures \initialized(param1);
assigns \result, __fc_stdout->__fc_FILE_data, *param1;
assigns \result
@@ -199,8 +199,8 @@ int printf_va_1(char const * restrict format);
*/
int printf_va_2(char const * restrict format, char *param0, int *param1);
-/*@ requires valid_read_string(format);
- requires valid_read_wstring(param0);
+/*@ requires valid_read_wstring(param0);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
@@ -213,8 +213,8 @@ int printf_va_2(char const * restrict format, char *param0, int *param1);
*/
int printf_va_3(char const * restrict format, wchar_t *param0);
-/*@ requires valid_read_string(format);
- requires \valid(param1);
+/*@ requires \valid(param1);
+ requires valid_read_string(format);
ensures \initialized(param1);
assigns \result, __fc_stdout->__fc_FILE_data, *param1;
assigns \result
@@ -232,8 +232,8 @@ int printf_va_3(char const * restrict format, wchar_t *param0);
*/
int printf_va_4(char const * restrict format, int param0, signed char *param1);
-/*@ requires valid_read_string(format);
- requires \valid(param1);
+/*@ requires \valid(param1);
+ requires valid_read_string(format);
ensures \initialized(param1);
assigns \result, __fc_stdout->__fc_FILE_data, *param1;
assigns \result
@@ -251,8 +251,8 @@ int printf_va_4(char const * restrict format, int param0, signed char *param1);
*/
int printf_va_5(char const * restrict format, int param0, short *param1);
-/*@ requires valid_read_string(format);
- requires \valid(param1);
+/*@ requires \valid(param1);
+ requires valid_read_string(format);
ensures \initialized(param1);
assigns \result, __fc_stdout->__fc_FILE_data, *param1;
assigns \result
@@ -270,8 +270,8 @@ int printf_va_5(char const * restrict format, int param0, short *param1);
*/
int printf_va_6(char const * restrict format, int param0, long *param1);
-/*@ requires valid_read_string(format);
- requires \valid(param1);
+/*@ requires \valid(param1);
+ requires valid_read_string(format);
ensures \initialized(param1);
assigns \result, __fc_stdout->__fc_FILE_data, *param1;
assigns \result
@@ -289,8 +289,8 @@ int printf_va_6(char const * restrict format, int param0, long *param1);
*/
int printf_va_7(char const * restrict format, long param0, long long *param1);
-/*@ requires valid_read_string(format);
- requires \valid(param1);
+/*@ requires \valid(param1);
+ requires valid_read_string(format);
ensures \initialized(param1);
assigns \result, __fc_stdout->__fc_FILE_data, *param1;
assigns \result
@@ -309,8 +309,8 @@ int printf_va_7(char const * restrict format, long param0, long long *param1);
int printf_va_8(char const * restrict format, long long param0,
intmax_t *param1);
-/*@ requires valid_read_string(format);
- requires \valid(param1);
+/*@ requires \valid(param1);
+ requires valid_read_string(format);
ensures \initialized(param1);
assigns \result, __fc_stdout->__fc_FILE_data, *param1;
assigns \result
@@ -328,8 +328,8 @@ int printf_va_8(char const * restrict format, long long param0,
*/
int printf_va_9(char const * restrict format, intmax_t param0, size_t *param1);
-/*@ requires valid_read_string(format);
- requires \valid(param1);
+/*@ requires \valid(param1);
+ requires valid_read_string(format);
ensures \initialized(param1);
assigns \result, __fc_stdout->__fc_FILE_data, *param1;
assigns \result
@@ -562,8 +562,8 @@ int printf_va_25(char const * restrict format, void *param0);
int printf_va_26(char const * restrict format, int param0, int param1,
int param2, unsigned int param3);
-/*@ requires valid_read_string(format);
- requires valid_read_nstring(param1, param0);
+/*@ requires valid_read_nstring(param1, param0);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
@@ -577,8 +577,8 @@ int printf_va_26(char const * restrict format, int param0, int param1,
*/
int printf_va_27(char const * restrict format, int param0, char *param1);
-/*@ requires valid_read_string(format);
- requires valid_read_nstring(param0, 4);
+/*@ requires valid_read_nstring(param0, 4);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
diff --git a/src/plugins/variadic/tests/known/oracle/printf_wrong_pointers.res.oracle b/src/plugins/variadic/tests/known/oracle/printf_wrong_pointers.res.oracle
index e8f9254834d4a3ac563d056c93856603f5898fb2..90f907e7b0fb2a779cea9537aa86efa62de964da 100644
--- a/src/plugins/variadic/tests/known/oracle/printf_wrong_pointers.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/printf_wrong_pointers.res.oracle
@@ -52,8 +52,8 @@
#include "stdarg.h"
#include "stddef.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdout->__fc_FILE_data, *param0;
assigns \result
@@ -69,8 +69,8 @@
*/
int printf_va_1(char const * restrict format, int *param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdout->__fc_FILE_data, *param0;
assigns \result
@@ -86,8 +86,8 @@ int printf_va_1(char const * restrict format, int *param0);
*/
int printf_va_2(char const * restrict format, int *param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdout->__fc_FILE_data, *param0;
assigns \result
@@ -103,8 +103,8 @@ int printf_va_2(char const * restrict format, int *param0);
*/
int printf_va_3(char const * restrict format, signed char *param0);
-/*@ requires valid_read_string(format);
- requires valid_read_string(param0);
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
@@ -117,8 +117,8 @@ int printf_va_3(char const * restrict format, signed char *param0);
*/
int printf_va_4(char const * restrict format, char *param0);
-/*@ requires valid_read_string(format);
- requires valid_read_wstring(param0);
+/*@ requires valid_read_wstring(param0);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
diff --git a/src/plugins/variadic/tests/known/oracle/printf_wrong_types.res.oracle b/src/plugins/variadic/tests/known/oracle/printf_wrong_types.res.oracle
index e692e0801f624d0e90ff078fc63c789dd6543b81..cdc57a22aae9b2a20b0cb946f1fb42a61b0d731f 100644
--- a/src/plugins/variadic/tests/known/oracle/printf_wrong_types.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/printf_wrong_types.res.oracle
@@ -262,8 +262,8 @@ int printf_va_11(char const * restrict format, double param0);
*/
int printf_va_12(char const * restrict format, long double param0);
-/*@ requires valid_read_string(format);
- requires valid_read_string(param0);
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
@@ -672,8 +672,8 @@ int printf_va_11(char const * restrict format, double param0);
*/
int printf_va_12(char const * restrict format, long double param0);
-/*@ requires valid_read_string(format);
- requires valid_read_string(param0);
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
diff --git a/src/plugins/variadic/tests/known/oracle/scanf.res.oracle b/src/plugins/variadic/tests/known/oracle/scanf.res.oracle
index dd3d00e9e6dc85a1fce8a678d672f8271f0ac429..3eecc8a2862f226537cd1f8d4fbcf28bb26045ec 100644
--- a/src/plugins/variadic/tests/known/oracle/scanf.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/scanf.res.oracle
@@ -33,11 +33,11 @@
#include "stdarg.h"
#include "stddef.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
+/*@ requires \valid(param1);
requires \valid(param2);
- requires \valid(param1);
- ensures \initialized(param2);
+ requires valid_read_string(format);
ensures \initialized(param1);
+ ensures \initialized(param2);
assigns \result, __fc_stdin->__fc_FILE_data, *param2, *param1,
*(param0 + (0 ..));
assigns \result
diff --git a/src/plugins/variadic/tests/known/oracle/scanf_loop.res.oracle b/src/plugins/variadic/tests/known/oracle/scanf_loop.res.oracle
index 9c0a537c04bc7d0c222f1a5d3583891c512a104d..3ea7bd6ac928f0b44b731d893844d951dd39fa5c 100644
--- a/src/plugins/variadic/tests/known/oracle/scanf_loop.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/scanf_loop.res.oracle
@@ -31,8 +31,8 @@
#include "stddef.h"
#include "stdio.h"
int volatile nondet;
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
diff --git a/src/plugins/variadic/tests/known/oracle/scanf_wrong.res.oracle b/src/plugins/variadic/tests/known/oracle/scanf_wrong.res.oracle
index 48109648487514aff47bd9bf33962376cb0dbe3a..2eb005e42169333d18e8000e2ae995dd6c778dad 100644
--- a/src/plugins/variadic/tests/known/oracle/scanf_wrong.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/scanf_wrong.res.oracle
@@ -34,11 +34,11 @@
#include "stdarg.h"
#include "stddef.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
+/*@ requires \valid(param1);
requires \valid(param2);
- requires \valid(param1);
- ensures \initialized(param2);
+ requires valid_read_string(format);
ensures \initialized(param1);
+ ensures \initialized(param2);
assigns \result, __fc_stdin->__fc_FILE_data, *param2, *param1,
*(param0 + (0 ..));
assigns \result
diff --git a/src/plugins/variadic/tests/known/oracle/snprintf.res.oracle b/src/plugins/variadic/tests/known/oracle/snprintf.res.oracle
index 296acd22116d6ed8a14eefa94d1d182981d57523..aeb7aa1c440e7559662cabfd91c8936f7eeda554 100644
--- a/src/plugins/variadic/tests/known/oracle/snprintf.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/snprintf.res.oracle
@@ -24,7 +24,7 @@
[eva] FRAMAC_SHARE/libc/string.h:121:
cannot evaluate ACSL term, unsupported ACSL construct: logic function memset
[eva] using specification for function snprintf_va_1
-[eva] tests/known/snprintf.c:12:
+[eva] FRAMAC_SHARE/libc/stdio.h:213:
Cannot evaluate range bound format_length(format) - 1
(unsupported ACSL construct: logic function format_length). Approximating
[eva:alarm] tests/known/snprintf.c:12: Warning:
@@ -49,11 +49,11 @@
#include "string.h"
#include "strings.h"
int volatile nondet;
-/*@ requires
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ requires
\valid(s + (0 .. n - 1)) ∨
\valid(s + (0 .. format_length(format) - 1));
- requires valid_read_string(format);
- requires valid_read_string(param0);
assigns \result, *(s + (0 ..));
assigns \result
\from (indirect: n), (indirect: *(format + (0 ..))),
@@ -64,11 +64,11 @@ int volatile nondet;
int snprintf_va_1(char * restrict s, size_t n, char const * restrict format,
char *param0);
-/*@ requires
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ requires
\valid(s + (0 .. n - 1)) ∨
\valid(s + (0 .. format_length(format) - 1));
- requires valid_read_string(format);
- requires valid_read_string(param0);
assigns \result, *(s + (0 ..));
assigns \result
\from (indirect: n), (indirect: *(format + (0 ..))),
diff --git a/src/plugins/variadic/tests/known/oracle/stdio_print.res.oracle b/src/plugins/variadic/tests/known/oracle/stdio_print.res.oracle
index 4d3deaa593847e59ebb1040064723eb24dc3bd34..1c6cbba330cc7157847d0047429c8f06bf4f487a 100644
--- a/src/plugins/variadic/tests/known/oracle/stdio_print.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/stdio_print.res.oracle
@@ -67,8 +67,8 @@
#include "stdarg.h"
#include "stddef.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires valid_read_string(param1);
+/*@ requires valid_read_string(param1);
+ requires valid_read_string(format);
assigns \result, stream->__fc_FILE_data;
assigns \result
\from (indirect: stream->__fc_FILE_id),
@@ -83,8 +83,8 @@
int fprintf_va_1(FILE * restrict stream, char const * restrict format,
int param0, char *param1, int param2);
-/*@ requires valid_read_string(format);
- requires valid_read_string(param1);
+/*@ requires valid_read_string(param1);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
@@ -99,11 +99,11 @@ int fprintf_va_1(FILE * restrict stream, char const * restrict format,
int printf_va_1(char const * restrict format, int param0, char *param1,
int param2);
-/*@ requires
+/*@ requires valid_read_string(param1);
+ requires valid_read_string(format);
+ requires
\valid(s + (0 .. n - 1)) ∨
\valid(s + (0 .. format_length(format) - 1));
- requires valid_read_string(format);
- requires valid_read_string(param1);
assigns \result, *(s + (0 ..));
assigns \result
\from (indirect: n), (indirect: *(format + (0 ..))),
@@ -116,8 +116,8 @@ int printf_va_1(char const * restrict format, int param0, char *param1,
int snprintf_va_1(char * restrict s, size_t n, char const * restrict format,
int param0, char *param1, int param2);
-/*@ requires valid_read_string(format);
- requires valid_read_string(param1);
+/*@ requires valid_read_string(param1);
+ requires valid_read_string(format);
assigns \result, *(s + (0 ..));
assigns \result
\from (indirect: *(format + (0 ..))), (indirect: param2),
@@ -129,9 +129,9 @@ int snprintf_va_1(char * restrict s, size_t n, char const * restrict format,
int sprintf_va_1(char * restrict s, char const * restrict format, int param0,
char *param1, int param2);
-/*@ requires valid_read_string(format);
+/*@ requires valid_read_string(param1);
requires valid_read_string(param2);
- requires valid_read_string(param1);
+ requires valid_read_string(format);
assigns \result;
assigns \result
\from (indirect: fd), (indirect: *(format + (0 ..))),
diff --git a/src/plugins/variadic/tests/known/oracle/stdio_scan.res.oracle b/src/plugins/variadic/tests/known/oracle/stdio_scan.res.oracle
index 0204089ba081519d1c242c1e2a2bccf6de947262..e9425f50afe0efde098eff7834483a9d71281e48 100644
--- a/src/plugins/variadic/tests/known/oracle/stdio_scan.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/stdio_scan.res.oracle
@@ -51,11 +51,11 @@
#include "stdarg.h"
#include "stddef.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
+/*@ requires \valid(param0);
requires \valid(param2);
- requires \valid(param0);
- ensures \initialized(param2);
+ requires valid_read_string(format);
ensures \initialized(param0);
+ ensures \initialized(param2);
assigns \result, stream->__fc_FILE_data, *param2, *(param1 + (0 ..)),
*param0;
assigns \result
@@ -78,11 +78,11 @@
int fscanf_va_1(FILE * restrict stream, char const * restrict format,
int *param0, char *param1, int *param2);
-/*@ requires valid_read_string(format);
+/*@ requires \valid(param0);
requires \valid(param2);
- requires \valid(param0);
- ensures \initialized(param2);
+ requires valid_read_string(format);
ensures \initialized(param0);
+ ensures \initialized(param2);
assigns \result, __fc_stdin->__fc_FILE_data, *param2, *(param1 + (0 ..)),
*param0;
assigns \result
@@ -105,12 +105,12 @@ int fscanf_va_1(FILE * restrict stream, char const * restrict format,
int scanf_va_1(char const * restrict format, int *param0, char *param1,
int *param2);
-/*@ requires valid_read_string(s);
- requires valid_read_string(format);
+/*@ requires \valid(param0);
requires \valid(param2);
- requires \valid(param0);
- ensures \initialized(param2);
+ requires valid_read_string(format);
+ requires valid_read_string(s);
ensures \initialized(param0);
+ ensures \initialized(param2);
assigns \result, *param2, *(param1 + (0 ..)), *param0;
assigns \result
\from (indirect: *(s + (0 ..))), (indirect: *(format + (0 ..)));
diff --git a/src/plugins/variadic/tests/known/oracle/swprintf.res.oracle b/src/plugins/variadic/tests/known/oracle/swprintf.res.oracle
index 326508d6ec1331114c74ad831beef0dcf890958c..8205df96d4a61e8c2a4eae55f86162b07d38e555 100644
--- a/src/plugins/variadic/tests/known/oracle/swprintf.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/swprintf.res.oracle
@@ -35,7 +35,7 @@
[eva] Initial state computed
[eva] using specification for function wmemset
[eva] using specification for function swprintf_va_1
-[eva] tests/known/swprintf.c:12:
+[eva] FRAMAC_SHARE/libc/wchar.h:274:
Cannot evaluate range bound wformat_length(format) - 1
(unsupported ACSL construct: logic function wformat_length). Approximating
[eva:alarm] tests/known/swprintf.c:12: Warning:
@@ -62,11 +62,11 @@
#include "time.h"
#include "wchar.h"
int volatile nondet;
-/*@ requires
+/*@ requires valid_read_wstring(param0);
+ requires valid_read_wstring(format);
+ requires
\valid(ws + (0 .. n - 1)) ∨
\valid(ws + (0 .. wformat_length(format) - 1));
- requires valid_read_wstring(format);
- requires valid_read_wstring(param0);
assigns \result, *(ws + (0 ..));
assigns \result
\from (indirect: n), (indirect: *(format + (0 ..))),
@@ -77,11 +77,11 @@ int volatile nondet;
int swprintf_va_1(wchar_t *ws, size_t n, wchar_t const *format,
wchar_t *param0);
-/*@ requires
+/*@ requires valid_read_wstring(param0);
+ requires valid_read_wstring(format);
+ requires
\valid(ws + (0 .. n - 1)) ∨
\valid(ws + (0 .. wformat_length(format) - 1));
- requires valid_read_wstring(format);
- requires valid_read_wstring(param0);
assigns \result, *(ws + (0 ..));
assigns \result
\from (indirect: n), (indirect: *(format + (0 ..))),
diff --git a/src/plugins/variadic/tests/known/oracle/wchar.res.oracle b/src/plugins/variadic/tests/known/oracle/wchar.res.oracle
index fb03056d82e92a3bd583652a7ce2d7835c903477..d04b2860030418ce2dc78f032a869e8c57636e53 100644
--- a/src/plugins/variadic/tests/known/oracle/wchar.res.oracle
+++ b/src/plugins/variadic/tests/known/oracle/wchar.res.oracle
@@ -164,8 +164,8 @@ int wprintf_va_4(wchar_t const *format, double param0, double param1,
*/
int wprintf_va_5(wchar_t const *format, int param0, int param1);
-/*@ requires valid_read_wstring(format);
- requires valid_read_wstring(param0);
+/*@ requires valid_read_wstring(param0);
+ requires valid_read_wstring(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
@@ -178,11 +178,11 @@ int wprintf_va_5(wchar_t const *format, int param0, int param1);
*/
int wprintf_va_6(wchar_t const *format, wchar_t *param0);
-/*@ requires
+/*@ requires valid_read_string(param0);
+ requires valid_read_wstring(format);
+ requires
\valid(ws + (0 .. n - 1)) ∨
\valid(ws + (0 .. wformat_length(format) - 1));
- requires valid_read_wstring(format);
- requires valid_read_string(param0);
assigns \result, *(ws + (0 ..));
assigns \result
\from (indirect: n), (indirect: *(format + (0 ..))),
@@ -209,11 +209,11 @@ int swprintf_va_1(wchar_t *ws, size_t n, wchar_t const *format, char *param0,
*/
int wscanf_va_1(wchar_t const *format, wchar_t *param0);
-/*@ requires valid_read_wstring(format);
+/*@ requires \valid(param0);
requires \valid(param1);
- requires \valid(param0);
- ensures \initialized(param1);
+ requires valid_read_wstring(format);
ensures \initialized(param0);
+ ensures \initialized(param1);
assigns \result, __fc_stdin->__fc_FILE_data, *param1, *param0;
assigns \result
\from (indirect: __fc_stdin->__fc_FILE_id),
@@ -231,9 +231,9 @@ int wscanf_va_1(wchar_t const *format, wchar_t *param0);
*/
int wscanf_va_2(wchar_t const *format, int *param0, int *param1);
-/*@ requires valid_read_wstring(str);
+/*@ requires \valid(param1);
requires valid_read_wstring(format);
- requires \valid(param1);
+ requires valid_read_wstring(str);
ensures \initialized(param1);
assigns \result, *param1, *(param0 + (0 ..));
assigns \result
diff --git a/src/plugins/variadic/va_build.ml b/src/plugins/variadic/va_build.ml
deleted file mode 100644
index b9d805e6c3cff55ce526755739d1d5eb04648b56..0000000000000000000000000000000000000000
--- a/src/plugins/variadic/va_build.ml
+++ /dev/null
@@ -1,112 +0,0 @@
-(**************************************************************************)
-(* *)
-(* This file is part of Frama-C. *)
-(* *)
-(* Copyright (C) 2007-2021 *)
-(* CEA (Commissariat à l'énergie atomique et aux énergies *)
-(* alternatives) *)
-(* *)
-(* you can redistribute it and/or modify it under the terms of the GNU *)
-(* Lesser General Public License as published by the Free Software *)
-(* Foundation, version 2.1. *)
-(* *)
-(* It is distributed in the hope that it will be useful, *)
-(* but WITHOUT ANY WARRANTY; without even the implied warranty of *)
-(* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *)
-(* GNU Lesser General Public License for more details. *)
-(* *)
-(* See the GNU Lesser General Public License version 2.1 *)
-(* for more details (enclosed in the file licenses/LGPLv2.1). *)
-(* *)
-(**************************************************************************)
-
-open Cil_types
-open Cil
-
-
-(* --- Cil builders --- *)
-
-let function_declaration ?vattr ~loc name typ mk_spec =
- (* Build the varinfo *)
- let vi = makeGlobalVar ~referenced:true name typ in
- Option.iter (fun extra_vattr -> vi.vattr <- vi.vattr @ extra_vattr) vattr;
- vi.vdecl <- loc;
- (* Build the formals *)
- setFormalsDecl vi typ;
- let formals = getFormalsDecl vi in
- let spec = mk_spec formals in
- (* Build the declaration statement *)
- let glob = GFunDecl (spec, vi, vi.vdecl) in
- vi, glob
-
-let vi_init ~loc vi exp = Local_init(vi, AssignInit (SingleInit exp), loc)
-
-let array_init ~loc fundec ~ghost scope name elem_typ values =
- let size = max (List.length values) 1 in (* In C, Array size >= 1 *)
- let esize = Cil.integer ~loc size in
- let typ = TArray (elem_typ, Some esize, Cil.empty_size_cache (), []) in
- let vi = Cil.makeLocalVar fundec ~ghost ~scope name typ in
- let initl =
- match values with
- | [] -> [ Index (Cil.zero ~loc, NoOffset), Cil.makeZeroInit ~loc elem_typ]
- | _ ->
- List.mapi
- (fun i exp -> Index (Cil.integer ~loc i, NoOffset), SingleInit exp)
- values
- in
- vi.vdefined <- true;
- vi, Local_init(vi, AssignInit(CompoundInit(typ,initl)), loc)
-
-let call ~loc lval callee args =
- let instr = Call (lval, (Cil.evar ~loc callee), args, loc) in
- Cil.mkStmtOneInstr ~valid_sid:true instr
-
-
-(* --- Logic builders --- *)
-
-let lvar vi =
- TVar (Cil.cvar_to_lvar vi), TNoOffset
-
-let tlval ~loc lval =
- Logic_const.term ~loc (TLval lval) (typeOfTermLval lval)
-
-let tvar ~loc vi =
- tlval ~loc (lvar vi)
-
-let tvarmem ~loc vi =
- TMem (tvar ~loc vi), TNoOffset
-
-let tvarfield ~loc vi fieldinfo =
- TMem (tvar ~loc vi), TField (fieldinfo, TNoOffset)
-
-let tresult typ =
- TResult typ, TNoOffset
-
-let tzero ~loc = Cil.lzero ~loc ()
-let tone ~loc = Cil.lone ~loc ()
-
-let tbinop ~loc binop t1 t2 =
- Logic_const.term ~loc (TBinOp (binop, t1, t2)) t1.term_type
-
-let tminus ~loc t1 t2 =
- tbinop ~loc MinusA t1 t2
-
-let tplus ~loc t1 t2 =
- tbinop ~loc PlusA t1 t2
-
-let trange ~loc tstart tend =
- Logic_const.trange ~loc (tstart, tend)
-
-let trange_from_vi ~loc vi =
- let var = tvar ~loc vi
- and range = trange ~loc (Some (tzero ~loc)) None in
- TMem (tbinop IndexPI ~loc var range), TNoOffset
-
-exception NotAFunction
-
-let tapp ~loc logic_info labels args =
- let ltyp = match logic_info.l_type with
- | None -> raise NotAFunction
- | Some ltyp -> ltyp
- in
- Logic_const.term ~loc (Tapp (logic_info, labels, args)) ltyp
diff --git a/tests/idct/oracle/ieee_1180_1990.res.oracle b/tests/idct/oracle/ieee_1180_1990.res.oracle
index c03bc0130e505d8cf9b19639ed38eb75b901253e..9f23868dd0dccaa94f1142abf3a7e6a05ee5b172 100644
--- a/tests/idct/oracle/ieee_1180_1990.res.oracle
+++ b/tests/idct/oracle/ieee_1180_1990.res.oracle
@@ -4195,12 +4195,12 @@
assert Eva: initialization: \initialized(&res[i].pme[j][k]);
By RedundantAlarms, with pending:
- Assertion 'Eva,initialization' (file tests/idct/ieee_1180_1990.c, line 368)
-[ Valid ] Instance of 'Pre-condition (file tests/idct/ieee_1180_1990.c, line 195)' at call 'printf_va_1' (file tests/idct/ieee_1180_1990.c, line 195)
+[ Valid ] Instance of 'Pre-condition (file share/libc/stdio.h, line 211)' at call 'printf_va_1' (file tests/idct/ieee_1180_1990.c, line 195)
status of 'requires
valid_read_string(format)' of printf_va_1 at stmt 238
by Eva.
-[ Valid ] Instance of 'Pre-condition (file tests/idct/ieee_1180_1990.c, line 196)' at call 'printf_va_2' (file tests/idct/ieee_1180_1990.c, line 196)
+[ Valid ] Instance of 'Pre-condition (file share/libc/stdio.h, line 211)' at call 'printf_va_2' (file tests/idct/ieee_1180_1990.c, line 196)
status of 'requires
valid_read_string(format)' of printf_va_2 at stmt 239
@@ -4210,22 +4210,22 @@
--- Properties of Function 'printf_va_1'
--------------------------------------------------------------------------------
-[ Valid ] Pre-condition (file tests/idct/ieee_1180_1990.c, line 195)
+[ Valid ] Pre-condition (file share/libc/stdio.h, line 211)
requires valid_read_string(format)
by Call Preconditions.
-[ Extern ] Assigns (file tests/idct/ieee_1180_1990.c, line 195)
+[ Extern ] Assigns (file share/libc/stdio.h, line 211)
assigns \result, __fc_stdout->__fc_FILE_data;
Unverifiable but considered Valid.
-[ Extern ] Froms (file tests/idct/ieee_1180_1990.c, line 195)
- assigns __fc_stdout->__fc_FILE_data
+[ Extern ] Froms (file share/libc/stdio.h, line 211)
+ assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
- __fc_stdout->__fc_FILE_data,
+ (indirect: __fc_stdout->__fc_FILE_data),
(indirect: *(format + (0 ..)));
Unverifiable but considered Valid.
-[ Extern ] Froms (file tests/idct/ieee_1180_1990.c, line 195)
- assigns \result
+[ Extern ] Froms (file share/libc/stdio.h, line 211)
+ assigns __fc_stdout->__fc_FILE_data
\from (indirect: __fc_stdout->__fc_FILE_id),
- (indirect: __fc_stdout->__fc_FILE_data),
+ __fc_stdout->__fc_FILE_data,
(indirect: *(format + (0 ..)));
Unverifiable but considered Valid.
[ Valid ] Default behavior
@@ -4236,22 +4236,22 @@
--- Properties of Function 'printf_va_2'
--------------------------------------------------------------------------------
-[ Valid ] Pre-condition (file tests/idct/ieee_1180_1990.c, line 196)
+[ Valid ] Pre-condition (file share/libc/stdio.h, line 211)
requires valid_read_string(format)
by Call Preconditions.
-[ Extern ] Assigns (file tests/idct/ieee_1180_1990.c, line 196)
+[ Extern ] Assigns (file share/libc/stdio.h, line 211)
assigns \result, __fc_stdout->__fc_FILE_data;
Unverifiable but considered Valid.
-[ Extern ] Froms (file tests/idct/ieee_1180_1990.c, line 196)
- assigns __fc_stdout->__fc_FILE_data
+[ Extern ] Froms (file share/libc/stdio.h, line 211)
+ assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
- __fc_stdout->__fc_FILE_data,
+ (indirect: __fc_stdout->__fc_FILE_data),
(indirect: *(format + (0 ..)));
Unverifiable but considered Valid.
-[ Extern ] Froms (file tests/idct/ieee_1180_1990.c, line 196)
- assigns \result
+[ Extern ] Froms (file share/libc/stdio.h, line 211)
+ assigns __fc_stdout->__fc_FILE_data
\from (indirect: __fc_stdout->__fc_FILE_id),
- (indirect: __fc_stdout->__fc_FILE_data),
+ __fc_stdout->__fc_FILE_data,
(indirect: *(format + (0 ..)));
Unverifiable but considered Valid.
[ Valid ] Default behavior
diff --git a/tests/libc/oracle/inttypes_h.0.res.oracle b/tests/libc/oracle/inttypes_h.0.res.oracle
index 9043fcd0699c2464552ea896e28d181e001c95d6..bbac05df763ba19327c103af44bb8cdc0fa5a2fe 100644
--- a/tests/libc/oracle/inttypes_h.0.res.oracle
+++ b/tests/libc/oracle/inttypes_h.0.res.oracle
@@ -6,8 +6,8 @@
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -36,8 +36,8 @@ int scanf_va_1(char const * restrict format, signed char *param0);
*/
int printf_va_1(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -66,8 +66,8 @@ int scanf_va_2(char const * restrict format, signed char *param0);
*/
int printf_va_2(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -96,8 +96,8 @@ int scanf_va_3(char const * restrict format, unsigned char *param0);
*/
int printf_va_3(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -126,8 +126,8 @@ int scanf_va_4(char const * restrict format, unsigned char *param0);
*/
int printf_va_4(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -156,8 +156,8 @@ int scanf_va_5(char const * restrict format, unsigned char *param0);
*/
int printf_va_5(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -186,8 +186,8 @@ int scanf_va_6(char const * restrict format, unsigned char *param0);
*/
int printf_va_6(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -216,8 +216,8 @@ int scanf_va_7(char const * restrict format, short *param0);
*/
int printf_va_7(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -246,8 +246,8 @@ int scanf_va_8(char const * restrict format, short *param0);
*/
int printf_va_8(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -276,8 +276,8 @@ int scanf_va_9(char const * restrict format, unsigned short *param0);
*/
int printf_va_9(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -306,8 +306,8 @@ int scanf_va_10(char const * restrict format, unsigned short *param0);
*/
int printf_va_10(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -336,8 +336,8 @@ int scanf_va_11(char const * restrict format, unsigned short *param0);
*/
int printf_va_11(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -366,8 +366,8 @@ int scanf_va_12(char const * restrict format, unsigned short *param0);
*/
int printf_va_12(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -396,8 +396,8 @@ int scanf_va_13(char const * restrict format, long *param0);
*/
int printf_va_13(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -426,8 +426,8 @@ int scanf_va_14(char const * restrict format, long *param0);
*/
int printf_va_14(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -456,8 +456,8 @@ int scanf_va_15(char const * restrict format, unsigned long *param0);
*/
int printf_va_15(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -486,8 +486,8 @@ int scanf_va_16(char const * restrict format, unsigned long *param0);
*/
int printf_va_16(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -516,8 +516,8 @@ int scanf_va_17(char const * restrict format, unsigned long *param0);
*/
int printf_va_17(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -546,8 +546,8 @@ int scanf_va_18(char const * restrict format, unsigned long *param0);
*/
int printf_va_18(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -576,8 +576,8 @@ int scanf_va_19(char const * restrict format, long long *param0);
*/
int printf_va_19(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -606,8 +606,8 @@ int scanf_va_20(char const * restrict format, long long *param0);
*/
int printf_va_20(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -636,8 +636,8 @@ int scanf_va_21(char const * restrict format, unsigned long long *param0);
*/
int printf_va_21(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -666,8 +666,8 @@ int scanf_va_22(char const * restrict format, unsigned long long *param0);
*/
int printf_va_22(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -696,8 +696,8 @@ int scanf_va_23(char const * restrict format, unsigned long long *param0);
*/
int printf_va_23(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -726,8 +726,8 @@ int scanf_va_24(char const * restrict format, unsigned long long *param0);
*/
int printf_va_24(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -756,8 +756,8 @@ int scanf_va_25(char const * restrict format, signed char *param0);
*/
int printf_va_25(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -786,8 +786,8 @@ int scanf_va_26(char const * restrict format, signed char *param0);
*/
int printf_va_26(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -816,8 +816,8 @@ int scanf_va_27(char const * restrict format, unsigned char *param0);
*/
int printf_va_27(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -846,8 +846,8 @@ int scanf_va_28(char const * restrict format, unsigned char *param0);
*/
int printf_va_28(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -876,8 +876,8 @@ int scanf_va_29(char const * restrict format, unsigned char *param0);
*/
int printf_va_29(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -906,8 +906,8 @@ int scanf_va_30(char const * restrict format, unsigned char *param0);
*/
int printf_va_30(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -936,8 +936,8 @@ int scanf_va_31(char const * restrict format, short *param0);
*/
int printf_va_31(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -966,8 +966,8 @@ int scanf_va_32(char const * restrict format, short *param0);
*/
int printf_va_32(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -996,8 +996,8 @@ int scanf_va_33(char const * restrict format, unsigned short *param0);
*/
int printf_va_33(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1026,8 +1026,8 @@ int scanf_va_34(char const * restrict format, unsigned short *param0);
*/
int printf_va_34(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1056,8 +1056,8 @@ int scanf_va_35(char const * restrict format, unsigned short *param0);
*/
int printf_va_35(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1086,8 +1086,8 @@ int scanf_va_36(char const * restrict format, unsigned short *param0);
*/
int printf_va_36(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1116,8 +1116,8 @@ int scanf_va_37(char const * restrict format, long *param0);
*/
int printf_va_37(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1146,8 +1146,8 @@ int scanf_va_38(char const * restrict format, long *param0);
*/
int printf_va_38(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1176,8 +1176,8 @@ int scanf_va_39(char const * restrict format, unsigned long *param0);
*/
int printf_va_39(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1206,8 +1206,8 @@ int scanf_va_40(char const * restrict format, unsigned long *param0);
*/
int printf_va_40(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1236,8 +1236,8 @@ int scanf_va_41(char const * restrict format, unsigned long *param0);
*/
int printf_va_41(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1266,8 +1266,8 @@ int scanf_va_42(char const * restrict format, unsigned long *param0);
*/
int printf_va_42(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1296,8 +1296,8 @@ int scanf_va_43(char const * restrict format, long long *param0);
*/
int printf_va_43(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1326,8 +1326,8 @@ int scanf_va_44(char const * restrict format, long long *param0);
*/
int printf_va_44(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1356,8 +1356,8 @@ int scanf_va_45(char const * restrict format, unsigned long long *param0);
*/
int printf_va_45(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1386,8 +1386,8 @@ int scanf_va_46(char const * restrict format, unsigned long long *param0);
*/
int printf_va_46(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1416,8 +1416,8 @@ int scanf_va_47(char const * restrict format, unsigned long long *param0);
*/
int printf_va_47(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1446,8 +1446,8 @@ int scanf_va_48(char const * restrict format, unsigned long long *param0);
*/
int printf_va_48(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1476,8 +1476,8 @@ int scanf_va_49(char const * restrict format, signed char *param0);
*/
int printf_va_49(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1506,8 +1506,8 @@ int scanf_va_50(char const * restrict format, signed char *param0);
*/
int printf_va_50(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1536,8 +1536,8 @@ int scanf_va_51(char const * restrict format, unsigned char *param0);
*/
int printf_va_51(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1566,8 +1566,8 @@ int scanf_va_52(char const * restrict format, unsigned char *param0);
*/
int printf_va_52(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1596,8 +1596,8 @@ int scanf_va_53(char const * restrict format, unsigned char *param0);
*/
int printf_va_53(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1626,8 +1626,8 @@ int scanf_va_54(char const * restrict format, unsigned char *param0);
*/
int printf_va_54(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1656,8 +1656,8 @@ int scanf_va_55(char const * restrict format, int *param0);
*/
int printf_va_55(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1686,8 +1686,8 @@ int scanf_va_56(char const * restrict format, int *param0);
*/
int printf_va_56(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1716,8 +1716,8 @@ int scanf_va_57(char const * restrict format, unsigned int *param0);
*/
int printf_va_57(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1746,8 +1746,8 @@ int scanf_va_58(char const * restrict format, unsigned int *param0);
*/
int printf_va_58(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1776,8 +1776,8 @@ int scanf_va_59(char const * restrict format, unsigned int *param0);
*/
int printf_va_59(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1806,8 +1806,8 @@ int scanf_va_60(char const * restrict format, unsigned int *param0);
*/
int printf_va_60(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1836,8 +1836,8 @@ int scanf_va_61(char const * restrict format, long *param0);
*/
int printf_va_61(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1866,8 +1866,8 @@ int scanf_va_62(char const * restrict format, long *param0);
*/
int printf_va_62(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1896,8 +1896,8 @@ int scanf_va_63(char const * restrict format, unsigned long *param0);
*/
int printf_va_63(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1926,8 +1926,8 @@ int scanf_va_64(char const * restrict format, unsigned long *param0);
*/
int printf_va_64(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1956,8 +1956,8 @@ int scanf_va_65(char const * restrict format, unsigned long *param0);
*/
int printf_va_65(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1986,8 +1986,8 @@ int scanf_va_66(char const * restrict format, unsigned long *param0);
*/
int printf_va_66(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2016,8 +2016,8 @@ int scanf_va_67(char const * restrict format, long long *param0);
*/
int printf_va_67(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2046,8 +2046,8 @@ int scanf_va_68(char const * restrict format, long long *param0);
*/
int printf_va_68(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2076,8 +2076,8 @@ int scanf_va_69(char const * restrict format, unsigned long long *param0);
*/
int printf_va_69(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2106,8 +2106,8 @@ int scanf_va_70(char const * restrict format, unsigned long long *param0);
*/
int printf_va_70(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2136,8 +2136,8 @@ int scanf_va_71(char const * restrict format, unsigned long long *param0);
*/
int printf_va_71(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2166,8 +2166,8 @@ int scanf_va_72(char const * restrict format, unsigned long long *param0);
*/
int printf_va_72(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2196,8 +2196,8 @@ int scanf_va_73(char const * restrict format, long long *param0);
*/
int printf_va_73(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2226,8 +2226,8 @@ int scanf_va_74(char const * restrict format, long long *param0);
*/
int printf_va_74(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2256,8 +2256,8 @@ int scanf_va_75(char const * restrict format, unsigned long long *param0);
*/
int printf_va_75(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2286,8 +2286,8 @@ int scanf_va_76(char const * restrict format, unsigned long long *param0);
*/
int printf_va_76(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2316,8 +2316,8 @@ int scanf_va_77(char const * restrict format, unsigned long long *param0);
*/
int printf_va_77(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2346,8 +2346,8 @@ int scanf_va_78(char const * restrict format, unsigned long long *param0);
*/
int printf_va_78(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2376,8 +2376,8 @@ int scanf_va_79(char const * restrict format, long *param0);
*/
int printf_va_79(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2406,8 +2406,8 @@ int scanf_va_80(char const * restrict format, long *param0);
*/
int printf_va_80(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2436,8 +2436,8 @@ int scanf_va_81(char const * restrict format, unsigned long *param0);
*/
int printf_va_81(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2466,8 +2466,8 @@ int scanf_va_82(char const * restrict format, unsigned long *param0);
*/
int printf_va_82(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2496,8 +2496,8 @@ int scanf_va_83(char const * restrict format, unsigned long *param0);
*/
int printf_va_83(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
diff --git a/tests/libc/oracle/inttypes_h.1.res.oracle b/tests/libc/oracle/inttypes_h.1.res.oracle
index 90c1f742453f5cefd167915b0b1459fd772289a3..6287272333f1c78e4248b503efdffe9ee805809c 100644
--- a/tests/libc/oracle/inttypes_h.1.res.oracle
+++ b/tests/libc/oracle/inttypes_h.1.res.oracle
@@ -6,8 +6,8 @@
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -36,8 +36,8 @@ int scanf_va_1(char const * restrict format, signed char *param0);
*/
int printf_va_1(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -66,8 +66,8 @@ int scanf_va_2(char const * restrict format, signed char *param0);
*/
int printf_va_2(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -96,8 +96,8 @@ int scanf_va_3(char const * restrict format, unsigned char *param0);
*/
int printf_va_3(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -126,8 +126,8 @@ int scanf_va_4(char const * restrict format, unsigned char *param0);
*/
int printf_va_4(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -156,8 +156,8 @@ int scanf_va_5(char const * restrict format, unsigned char *param0);
*/
int printf_va_5(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -186,8 +186,8 @@ int scanf_va_6(char const * restrict format, unsigned char *param0);
*/
int printf_va_6(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -216,8 +216,8 @@ int scanf_va_7(char const * restrict format, short *param0);
*/
int printf_va_7(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -246,8 +246,8 @@ int scanf_va_8(char const * restrict format, short *param0);
*/
int printf_va_8(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -276,8 +276,8 @@ int scanf_va_9(char const * restrict format, unsigned short *param0);
*/
int printf_va_9(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -306,8 +306,8 @@ int scanf_va_10(char const * restrict format, unsigned short *param0);
*/
int printf_va_10(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -336,8 +336,8 @@ int scanf_va_11(char const * restrict format, unsigned short *param0);
*/
int printf_va_11(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -366,8 +366,8 @@ int scanf_va_12(char const * restrict format, unsigned short *param0);
*/
int printf_va_12(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -396,8 +396,8 @@ int scanf_va_13(char const * restrict format, int *param0);
*/
int printf_va_13(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -426,8 +426,8 @@ int scanf_va_14(char const * restrict format, int *param0);
*/
int printf_va_14(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -456,8 +456,8 @@ int scanf_va_15(char const * restrict format, unsigned int *param0);
*/
int printf_va_15(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -486,8 +486,8 @@ int scanf_va_16(char const * restrict format, unsigned int *param0);
*/
int printf_va_16(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -516,8 +516,8 @@ int scanf_va_17(char const * restrict format, unsigned int *param0);
*/
int printf_va_17(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -546,8 +546,8 @@ int scanf_va_18(char const * restrict format, unsigned int *param0);
*/
int printf_va_18(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -576,8 +576,8 @@ int scanf_va_19(char const * restrict format, long long *param0);
*/
int printf_va_19(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -606,8 +606,8 @@ int scanf_va_20(char const * restrict format, long long *param0);
*/
int printf_va_20(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -636,8 +636,8 @@ int scanf_va_21(char const * restrict format, unsigned long long *param0);
*/
int printf_va_21(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -666,8 +666,8 @@ int scanf_va_22(char const * restrict format, unsigned long long *param0);
*/
int printf_va_22(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -696,8 +696,8 @@ int scanf_va_23(char const * restrict format, unsigned long long *param0);
*/
int printf_va_23(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -726,8 +726,8 @@ int scanf_va_24(char const * restrict format, unsigned long long *param0);
*/
int printf_va_24(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -756,8 +756,8 @@ int scanf_va_25(char const * restrict format, signed char *param0);
*/
int printf_va_25(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -786,8 +786,8 @@ int scanf_va_26(char const * restrict format, signed char *param0);
*/
int printf_va_26(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -816,8 +816,8 @@ int scanf_va_27(char const * restrict format, unsigned char *param0);
*/
int printf_va_27(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -846,8 +846,8 @@ int scanf_va_28(char const * restrict format, unsigned char *param0);
*/
int printf_va_28(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -876,8 +876,8 @@ int scanf_va_29(char const * restrict format, unsigned char *param0);
*/
int printf_va_29(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -906,8 +906,8 @@ int scanf_va_30(char const * restrict format, unsigned char *param0);
*/
int printf_va_30(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -936,8 +936,8 @@ int scanf_va_31(char const * restrict format, short *param0);
*/
int printf_va_31(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -966,8 +966,8 @@ int scanf_va_32(char const * restrict format, short *param0);
*/
int printf_va_32(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -996,8 +996,8 @@ int scanf_va_33(char const * restrict format, unsigned short *param0);
*/
int printf_va_33(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1026,8 +1026,8 @@ int scanf_va_34(char const * restrict format, unsigned short *param0);
*/
int printf_va_34(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1056,8 +1056,8 @@ int scanf_va_35(char const * restrict format, unsigned short *param0);
*/
int printf_va_35(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1086,8 +1086,8 @@ int scanf_va_36(char const * restrict format, unsigned short *param0);
*/
int printf_va_36(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1116,8 +1116,8 @@ int scanf_va_37(char const * restrict format, int *param0);
*/
int printf_va_37(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1146,8 +1146,8 @@ int scanf_va_38(char const * restrict format, int *param0);
*/
int printf_va_38(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1176,8 +1176,8 @@ int scanf_va_39(char const * restrict format, unsigned int *param0);
*/
int printf_va_39(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1206,8 +1206,8 @@ int scanf_va_40(char const * restrict format, unsigned int *param0);
*/
int printf_va_40(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1236,8 +1236,8 @@ int scanf_va_41(char const * restrict format, unsigned int *param0);
*/
int printf_va_41(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1266,8 +1266,8 @@ int scanf_va_42(char const * restrict format, unsigned int *param0);
*/
int printf_va_42(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1296,8 +1296,8 @@ int scanf_va_43(char const * restrict format, long long *param0);
*/
int printf_va_43(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1326,8 +1326,8 @@ int scanf_va_44(char const * restrict format, long long *param0);
*/
int printf_va_44(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1356,8 +1356,8 @@ int scanf_va_45(char const * restrict format, unsigned long long *param0);
*/
int printf_va_45(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1386,8 +1386,8 @@ int scanf_va_46(char const * restrict format, unsigned long long *param0);
*/
int printf_va_46(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1416,8 +1416,8 @@ int scanf_va_47(char const * restrict format, unsigned long long *param0);
*/
int printf_va_47(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1446,8 +1446,8 @@ int scanf_va_48(char const * restrict format, unsigned long long *param0);
*/
int printf_va_48(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1476,8 +1476,8 @@ int scanf_va_49(char const * restrict format, signed char *param0);
*/
int printf_va_49(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1506,8 +1506,8 @@ int scanf_va_50(char const * restrict format, signed char *param0);
*/
int printf_va_50(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1536,8 +1536,8 @@ int scanf_va_51(char const * restrict format, unsigned char *param0);
*/
int printf_va_51(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1566,8 +1566,8 @@ int scanf_va_52(char const * restrict format, unsigned char *param0);
*/
int printf_va_52(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1596,8 +1596,8 @@ int scanf_va_53(char const * restrict format, unsigned char *param0);
*/
int printf_va_53(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1626,8 +1626,8 @@ int scanf_va_54(char const * restrict format, unsigned char *param0);
*/
int printf_va_54(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1656,8 +1656,8 @@ int scanf_va_55(char const * restrict format, int *param0);
*/
int printf_va_55(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1686,8 +1686,8 @@ int scanf_va_56(char const * restrict format, int *param0);
*/
int printf_va_56(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1716,8 +1716,8 @@ int scanf_va_57(char const * restrict format, unsigned int *param0);
*/
int printf_va_57(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1746,8 +1746,8 @@ int scanf_va_58(char const * restrict format, unsigned int *param0);
*/
int printf_va_58(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1776,8 +1776,8 @@ int scanf_va_59(char const * restrict format, unsigned int *param0);
*/
int printf_va_59(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1806,8 +1806,8 @@ int scanf_va_60(char const * restrict format, unsigned int *param0);
*/
int printf_va_60(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1836,8 +1836,8 @@ int scanf_va_61(char const * restrict format, int *param0);
*/
int printf_va_61(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1866,8 +1866,8 @@ int scanf_va_62(char const * restrict format, int *param0);
*/
int printf_va_62(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1896,8 +1896,8 @@ int scanf_va_63(char const * restrict format, unsigned int *param0);
*/
int printf_va_63(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1926,8 +1926,8 @@ int scanf_va_64(char const * restrict format, unsigned int *param0);
*/
int printf_va_64(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1956,8 +1956,8 @@ int scanf_va_65(char const * restrict format, unsigned int *param0);
*/
int printf_va_65(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1986,8 +1986,8 @@ int scanf_va_66(char const * restrict format, unsigned int *param0);
*/
int printf_va_66(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2016,8 +2016,8 @@ int scanf_va_67(char const * restrict format, long long *param0);
*/
int printf_va_67(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2046,8 +2046,8 @@ int scanf_va_68(char const * restrict format, long long *param0);
*/
int printf_va_68(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2076,8 +2076,8 @@ int scanf_va_69(char const * restrict format, unsigned long long *param0);
*/
int printf_va_69(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2106,8 +2106,8 @@ int scanf_va_70(char const * restrict format, unsigned long long *param0);
*/
int printf_va_70(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2136,8 +2136,8 @@ int scanf_va_71(char const * restrict format, unsigned long long *param0);
*/
int printf_va_71(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2166,8 +2166,8 @@ int scanf_va_72(char const * restrict format, unsigned long long *param0);
*/
int printf_va_72(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2196,8 +2196,8 @@ int scanf_va_73(char const * restrict format, long long *param0);
*/
int printf_va_73(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2226,8 +2226,8 @@ int scanf_va_74(char const * restrict format, long long *param0);
*/
int printf_va_74(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2256,8 +2256,8 @@ int scanf_va_75(char const * restrict format, unsigned long long *param0);
*/
int printf_va_75(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2286,8 +2286,8 @@ int scanf_va_76(char const * restrict format, unsigned long long *param0);
*/
int printf_va_76(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2316,8 +2316,8 @@ int scanf_va_77(char const * restrict format, unsigned long long *param0);
*/
int printf_va_77(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2346,8 +2346,8 @@ int scanf_va_78(char const * restrict format, unsigned long long *param0);
*/
int printf_va_78(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2376,8 +2376,8 @@ int scanf_va_79(char const * restrict format, int *param0);
*/
int printf_va_79(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2406,8 +2406,8 @@ int scanf_va_80(char const * restrict format, int *param0);
*/
int printf_va_80(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2436,8 +2436,8 @@ int scanf_va_81(char const * restrict format, unsigned int *param0);
*/
int printf_va_81(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2466,8 +2466,8 @@ int scanf_va_82(char const * restrict format, unsigned int *param0);
*/
int printf_va_82(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2496,8 +2496,8 @@ int scanf_va_83(char const * restrict format, unsigned int *param0);
*/
int printf_va_83(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
diff --git a/tests/libc/oracle/inttypes_h.2.res.oracle b/tests/libc/oracle/inttypes_h.2.res.oracle
index 97acd045fd99a436d4c632a35ca8a2039d37cf52..92e41aa30a46fc7b7c5d20da5e32619e6dea3603 100644
--- a/tests/libc/oracle/inttypes_h.2.res.oracle
+++ b/tests/libc/oracle/inttypes_h.2.res.oracle
@@ -6,8 +6,8 @@
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -36,8 +36,8 @@ int scanf_va_1(char const * restrict format, signed char *param0);
*/
int printf_va_1(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -66,8 +66,8 @@ int scanf_va_2(char const * restrict format, signed char *param0);
*/
int printf_va_2(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -96,8 +96,8 @@ int scanf_va_3(char const * restrict format, unsigned char *param0);
*/
int printf_va_3(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -126,8 +126,8 @@ int scanf_va_4(char const * restrict format, unsigned char *param0);
*/
int printf_va_4(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -156,8 +156,8 @@ int scanf_va_5(char const * restrict format, unsigned char *param0);
*/
int printf_va_5(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -186,8 +186,8 @@ int scanf_va_6(char const * restrict format, unsigned char *param0);
*/
int printf_va_6(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -216,8 +216,8 @@ int scanf_va_7(char const * restrict format, short *param0);
*/
int printf_va_7(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -246,8 +246,8 @@ int scanf_va_8(char const * restrict format, short *param0);
*/
int printf_va_8(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -276,8 +276,8 @@ int scanf_va_9(char const * restrict format, unsigned short *param0);
*/
int printf_va_9(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -306,8 +306,8 @@ int scanf_va_10(char const * restrict format, unsigned short *param0);
*/
int printf_va_10(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -336,8 +336,8 @@ int scanf_va_11(char const * restrict format, unsigned short *param0);
*/
int printf_va_11(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -366,8 +366,8 @@ int scanf_va_12(char const * restrict format, unsigned short *param0);
*/
int printf_va_12(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -396,8 +396,8 @@ int scanf_va_13(char const * restrict format, int *param0);
*/
int printf_va_13(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -426,8 +426,8 @@ int scanf_va_14(char const * restrict format, int *param0);
*/
int printf_va_14(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -456,8 +456,8 @@ int scanf_va_15(char const * restrict format, unsigned int *param0);
*/
int printf_va_15(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -486,8 +486,8 @@ int scanf_va_16(char const * restrict format, unsigned int *param0);
*/
int printf_va_16(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -516,8 +516,8 @@ int scanf_va_17(char const * restrict format, unsigned int *param0);
*/
int printf_va_17(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -546,8 +546,8 @@ int scanf_va_18(char const * restrict format, unsigned int *param0);
*/
int printf_va_18(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -576,8 +576,8 @@ int scanf_va_19(char const * restrict format, long *param0);
*/
int printf_va_19(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -606,8 +606,8 @@ int scanf_va_20(char const * restrict format, long *param0);
*/
int printf_va_20(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -636,8 +636,8 @@ int scanf_va_21(char const * restrict format, unsigned long *param0);
*/
int printf_va_21(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -666,8 +666,8 @@ int scanf_va_22(char const * restrict format, unsigned long *param0);
*/
int printf_va_22(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -696,8 +696,8 @@ int scanf_va_23(char const * restrict format, unsigned long *param0);
*/
int printf_va_23(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -726,8 +726,8 @@ int scanf_va_24(char const * restrict format, unsigned long *param0);
*/
int printf_va_24(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -756,8 +756,8 @@ int scanf_va_25(char const * restrict format, signed char *param0);
*/
int printf_va_25(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -786,8 +786,8 @@ int scanf_va_26(char const * restrict format, signed char *param0);
*/
int printf_va_26(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -816,8 +816,8 @@ int scanf_va_27(char const * restrict format, unsigned char *param0);
*/
int printf_va_27(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -846,8 +846,8 @@ int scanf_va_28(char const * restrict format, unsigned char *param0);
*/
int printf_va_28(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -876,8 +876,8 @@ int scanf_va_29(char const * restrict format, unsigned char *param0);
*/
int printf_va_29(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -906,8 +906,8 @@ int scanf_va_30(char const * restrict format, unsigned char *param0);
*/
int printf_va_30(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -936,8 +936,8 @@ int scanf_va_31(char const * restrict format, short *param0);
*/
int printf_va_31(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -966,8 +966,8 @@ int scanf_va_32(char const * restrict format, short *param0);
*/
int printf_va_32(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -996,8 +996,8 @@ int scanf_va_33(char const * restrict format, unsigned short *param0);
*/
int printf_va_33(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1026,8 +1026,8 @@ int scanf_va_34(char const * restrict format, unsigned short *param0);
*/
int printf_va_34(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1056,8 +1056,8 @@ int scanf_va_35(char const * restrict format, unsigned short *param0);
*/
int printf_va_35(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1086,8 +1086,8 @@ int scanf_va_36(char const * restrict format, unsigned short *param0);
*/
int printf_va_36(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1116,8 +1116,8 @@ int scanf_va_37(char const * restrict format, int *param0);
*/
int printf_va_37(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1146,8 +1146,8 @@ int scanf_va_38(char const * restrict format, int *param0);
*/
int printf_va_38(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1176,8 +1176,8 @@ int scanf_va_39(char const * restrict format, unsigned int *param0);
*/
int printf_va_39(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1206,8 +1206,8 @@ int scanf_va_40(char const * restrict format, unsigned int *param0);
*/
int printf_va_40(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1236,8 +1236,8 @@ int scanf_va_41(char const * restrict format, unsigned int *param0);
*/
int printf_va_41(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1266,8 +1266,8 @@ int scanf_va_42(char const * restrict format, unsigned int *param0);
*/
int printf_va_42(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1296,8 +1296,8 @@ int scanf_va_43(char const * restrict format, long *param0);
*/
int printf_va_43(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1326,8 +1326,8 @@ int scanf_va_44(char const * restrict format, long *param0);
*/
int printf_va_44(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1356,8 +1356,8 @@ int scanf_va_45(char const * restrict format, unsigned long *param0);
*/
int printf_va_45(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1386,8 +1386,8 @@ int scanf_va_46(char const * restrict format, unsigned long *param0);
*/
int printf_va_46(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1416,8 +1416,8 @@ int scanf_va_47(char const * restrict format, unsigned long *param0);
*/
int printf_va_47(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1446,8 +1446,8 @@ int scanf_va_48(char const * restrict format, unsigned long *param0);
*/
int printf_va_48(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1476,8 +1476,8 @@ int scanf_va_49(char const * restrict format, signed char *param0);
*/
int printf_va_49(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1506,8 +1506,8 @@ int scanf_va_50(char const * restrict format, signed char *param0);
*/
int printf_va_50(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1536,8 +1536,8 @@ int scanf_va_51(char const * restrict format, unsigned char *param0);
*/
int printf_va_51(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1566,8 +1566,8 @@ int scanf_va_52(char const * restrict format, unsigned char *param0);
*/
int printf_va_52(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1596,8 +1596,8 @@ int scanf_va_53(char const * restrict format, unsigned char *param0);
*/
int printf_va_53(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1626,8 +1626,8 @@ int scanf_va_54(char const * restrict format, unsigned char *param0);
*/
int printf_va_54(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1656,8 +1656,8 @@ int scanf_va_55(char const * restrict format, int *param0);
*/
int printf_va_55(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1686,8 +1686,8 @@ int scanf_va_56(char const * restrict format, int *param0);
*/
int printf_va_56(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1716,8 +1716,8 @@ int scanf_va_57(char const * restrict format, unsigned int *param0);
*/
int printf_va_57(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1746,8 +1746,8 @@ int scanf_va_58(char const * restrict format, unsigned int *param0);
*/
int printf_va_58(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1776,8 +1776,8 @@ int scanf_va_59(char const * restrict format, unsigned int *param0);
*/
int printf_va_59(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1806,8 +1806,8 @@ int scanf_va_60(char const * restrict format, unsigned int *param0);
*/
int printf_va_60(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1836,8 +1836,8 @@ int scanf_va_61(char const * restrict format, int *param0);
*/
int printf_va_61(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1866,8 +1866,8 @@ int scanf_va_62(char const * restrict format, int *param0);
*/
int printf_va_62(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1896,8 +1896,8 @@ int scanf_va_63(char const * restrict format, unsigned int *param0);
*/
int printf_va_63(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1926,8 +1926,8 @@ int scanf_va_64(char const * restrict format, unsigned int *param0);
*/
int printf_va_64(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1956,8 +1956,8 @@ int scanf_va_65(char const * restrict format, unsigned int *param0);
*/
int printf_va_65(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1986,8 +1986,8 @@ int scanf_va_66(char const * restrict format, unsigned int *param0);
*/
int printf_va_66(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2016,8 +2016,8 @@ int scanf_va_67(char const * restrict format, long *param0);
*/
int printf_va_67(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2046,8 +2046,8 @@ int scanf_va_68(char const * restrict format, long *param0);
*/
int printf_va_68(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2076,8 +2076,8 @@ int scanf_va_69(char const * restrict format, unsigned long *param0);
*/
int printf_va_69(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2106,8 +2106,8 @@ int scanf_va_70(char const * restrict format, unsigned long *param0);
*/
int printf_va_70(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2136,8 +2136,8 @@ int scanf_va_71(char const * restrict format, unsigned long *param0);
*/
int printf_va_71(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2166,8 +2166,8 @@ int scanf_va_72(char const * restrict format, unsigned long *param0);
*/
int printf_va_72(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2196,8 +2196,8 @@ int scanf_va_73(char const * restrict format, long long *param0);
*/
int printf_va_73(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2226,8 +2226,8 @@ int scanf_va_74(char const * restrict format, long long *param0);
*/
int printf_va_74(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2256,8 +2256,8 @@ int scanf_va_75(char const * restrict format, unsigned long long *param0);
*/
int printf_va_75(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2286,8 +2286,8 @@ int scanf_va_76(char const * restrict format, unsigned long long *param0);
*/
int printf_va_76(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2316,8 +2316,8 @@ int scanf_va_77(char const * restrict format, unsigned long long *param0);
*/
int printf_va_77(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2346,8 +2346,8 @@ int scanf_va_78(char const * restrict format, unsigned long long *param0);
*/
int printf_va_78(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2376,8 +2376,8 @@ int scanf_va_79(char const * restrict format, long *param0);
*/
int printf_va_79(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2406,8 +2406,8 @@ int scanf_va_80(char const * restrict format, long *param0);
*/
int printf_va_80(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2436,8 +2436,8 @@ int scanf_va_81(char const * restrict format, unsigned long *param0);
*/
int printf_va_81(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2466,8 +2466,8 @@ int scanf_va_82(char const * restrict format, unsigned long *param0);
*/
int printf_va_82(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2496,8 +2496,8 @@ int scanf_va_83(char const * restrict format, unsigned long *param0);
*/
int printf_va_83(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
diff --git a/tests/libc/oracle/inttypes_h.3.res.oracle b/tests/libc/oracle/inttypes_h.3.res.oracle
index 9043fcd0699c2464552ea896e28d181e001c95d6..bbac05df763ba19327c103af44bb8cdc0fa5a2fe 100644
--- a/tests/libc/oracle/inttypes_h.3.res.oracle
+++ b/tests/libc/oracle/inttypes_h.3.res.oracle
@@ -6,8 +6,8 @@
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -36,8 +36,8 @@ int scanf_va_1(char const * restrict format, signed char *param0);
*/
int printf_va_1(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -66,8 +66,8 @@ int scanf_va_2(char const * restrict format, signed char *param0);
*/
int printf_va_2(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -96,8 +96,8 @@ int scanf_va_3(char const * restrict format, unsigned char *param0);
*/
int printf_va_3(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -126,8 +126,8 @@ int scanf_va_4(char const * restrict format, unsigned char *param0);
*/
int printf_va_4(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -156,8 +156,8 @@ int scanf_va_5(char const * restrict format, unsigned char *param0);
*/
int printf_va_5(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -186,8 +186,8 @@ int scanf_va_6(char const * restrict format, unsigned char *param0);
*/
int printf_va_6(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -216,8 +216,8 @@ int scanf_va_7(char const * restrict format, short *param0);
*/
int printf_va_7(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -246,8 +246,8 @@ int scanf_va_8(char const * restrict format, short *param0);
*/
int printf_va_8(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -276,8 +276,8 @@ int scanf_va_9(char const * restrict format, unsigned short *param0);
*/
int printf_va_9(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -306,8 +306,8 @@ int scanf_va_10(char const * restrict format, unsigned short *param0);
*/
int printf_va_10(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -336,8 +336,8 @@ int scanf_va_11(char const * restrict format, unsigned short *param0);
*/
int printf_va_11(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -366,8 +366,8 @@ int scanf_va_12(char const * restrict format, unsigned short *param0);
*/
int printf_va_12(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -396,8 +396,8 @@ int scanf_va_13(char const * restrict format, long *param0);
*/
int printf_va_13(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -426,8 +426,8 @@ int scanf_va_14(char const * restrict format, long *param0);
*/
int printf_va_14(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -456,8 +456,8 @@ int scanf_va_15(char const * restrict format, unsigned long *param0);
*/
int printf_va_15(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -486,8 +486,8 @@ int scanf_va_16(char const * restrict format, unsigned long *param0);
*/
int printf_va_16(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -516,8 +516,8 @@ int scanf_va_17(char const * restrict format, unsigned long *param0);
*/
int printf_va_17(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -546,8 +546,8 @@ int scanf_va_18(char const * restrict format, unsigned long *param0);
*/
int printf_va_18(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -576,8 +576,8 @@ int scanf_va_19(char const * restrict format, long long *param0);
*/
int printf_va_19(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -606,8 +606,8 @@ int scanf_va_20(char const * restrict format, long long *param0);
*/
int printf_va_20(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -636,8 +636,8 @@ int scanf_va_21(char const * restrict format, unsigned long long *param0);
*/
int printf_va_21(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -666,8 +666,8 @@ int scanf_va_22(char const * restrict format, unsigned long long *param0);
*/
int printf_va_22(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -696,8 +696,8 @@ int scanf_va_23(char const * restrict format, unsigned long long *param0);
*/
int printf_va_23(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -726,8 +726,8 @@ int scanf_va_24(char const * restrict format, unsigned long long *param0);
*/
int printf_va_24(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -756,8 +756,8 @@ int scanf_va_25(char const * restrict format, signed char *param0);
*/
int printf_va_25(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -786,8 +786,8 @@ int scanf_va_26(char const * restrict format, signed char *param0);
*/
int printf_va_26(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -816,8 +816,8 @@ int scanf_va_27(char const * restrict format, unsigned char *param0);
*/
int printf_va_27(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -846,8 +846,8 @@ int scanf_va_28(char const * restrict format, unsigned char *param0);
*/
int printf_va_28(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -876,8 +876,8 @@ int scanf_va_29(char const * restrict format, unsigned char *param0);
*/
int printf_va_29(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -906,8 +906,8 @@ int scanf_va_30(char const * restrict format, unsigned char *param0);
*/
int printf_va_30(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -936,8 +936,8 @@ int scanf_va_31(char const * restrict format, short *param0);
*/
int printf_va_31(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -966,8 +966,8 @@ int scanf_va_32(char const * restrict format, short *param0);
*/
int printf_va_32(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -996,8 +996,8 @@ int scanf_va_33(char const * restrict format, unsigned short *param0);
*/
int printf_va_33(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1026,8 +1026,8 @@ int scanf_va_34(char const * restrict format, unsigned short *param0);
*/
int printf_va_34(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1056,8 +1056,8 @@ int scanf_va_35(char const * restrict format, unsigned short *param0);
*/
int printf_va_35(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1086,8 +1086,8 @@ int scanf_va_36(char const * restrict format, unsigned short *param0);
*/
int printf_va_36(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1116,8 +1116,8 @@ int scanf_va_37(char const * restrict format, long *param0);
*/
int printf_va_37(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1146,8 +1146,8 @@ int scanf_va_38(char const * restrict format, long *param0);
*/
int printf_va_38(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1176,8 +1176,8 @@ int scanf_va_39(char const * restrict format, unsigned long *param0);
*/
int printf_va_39(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1206,8 +1206,8 @@ int scanf_va_40(char const * restrict format, unsigned long *param0);
*/
int printf_va_40(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1236,8 +1236,8 @@ int scanf_va_41(char const * restrict format, unsigned long *param0);
*/
int printf_va_41(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1266,8 +1266,8 @@ int scanf_va_42(char const * restrict format, unsigned long *param0);
*/
int printf_va_42(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1296,8 +1296,8 @@ int scanf_va_43(char const * restrict format, long long *param0);
*/
int printf_va_43(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1326,8 +1326,8 @@ int scanf_va_44(char const * restrict format, long long *param0);
*/
int printf_va_44(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1356,8 +1356,8 @@ int scanf_va_45(char const * restrict format, unsigned long long *param0);
*/
int printf_va_45(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1386,8 +1386,8 @@ int scanf_va_46(char const * restrict format, unsigned long long *param0);
*/
int printf_va_46(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1416,8 +1416,8 @@ int scanf_va_47(char const * restrict format, unsigned long long *param0);
*/
int printf_va_47(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1446,8 +1446,8 @@ int scanf_va_48(char const * restrict format, unsigned long long *param0);
*/
int printf_va_48(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1476,8 +1476,8 @@ int scanf_va_49(char const * restrict format, signed char *param0);
*/
int printf_va_49(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1506,8 +1506,8 @@ int scanf_va_50(char const * restrict format, signed char *param0);
*/
int printf_va_50(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1536,8 +1536,8 @@ int scanf_va_51(char const * restrict format, unsigned char *param0);
*/
int printf_va_51(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1566,8 +1566,8 @@ int scanf_va_52(char const * restrict format, unsigned char *param0);
*/
int printf_va_52(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1596,8 +1596,8 @@ int scanf_va_53(char const * restrict format, unsigned char *param0);
*/
int printf_va_53(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1626,8 +1626,8 @@ int scanf_va_54(char const * restrict format, unsigned char *param0);
*/
int printf_va_54(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1656,8 +1656,8 @@ int scanf_va_55(char const * restrict format, int *param0);
*/
int printf_va_55(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1686,8 +1686,8 @@ int scanf_va_56(char const * restrict format, int *param0);
*/
int printf_va_56(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1716,8 +1716,8 @@ int scanf_va_57(char const * restrict format, unsigned int *param0);
*/
int printf_va_57(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1746,8 +1746,8 @@ int scanf_va_58(char const * restrict format, unsigned int *param0);
*/
int printf_va_58(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1776,8 +1776,8 @@ int scanf_va_59(char const * restrict format, unsigned int *param0);
*/
int printf_va_59(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1806,8 +1806,8 @@ int scanf_va_60(char const * restrict format, unsigned int *param0);
*/
int printf_va_60(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1836,8 +1836,8 @@ int scanf_va_61(char const * restrict format, long *param0);
*/
int printf_va_61(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1866,8 +1866,8 @@ int scanf_va_62(char const * restrict format, long *param0);
*/
int printf_va_62(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1896,8 +1896,8 @@ int scanf_va_63(char const * restrict format, unsigned long *param0);
*/
int printf_va_63(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1926,8 +1926,8 @@ int scanf_va_64(char const * restrict format, unsigned long *param0);
*/
int printf_va_64(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1956,8 +1956,8 @@ int scanf_va_65(char const * restrict format, unsigned long *param0);
*/
int printf_va_65(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1986,8 +1986,8 @@ int scanf_va_66(char const * restrict format, unsigned long *param0);
*/
int printf_va_66(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2016,8 +2016,8 @@ int scanf_va_67(char const * restrict format, long long *param0);
*/
int printf_va_67(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2046,8 +2046,8 @@ int scanf_va_68(char const * restrict format, long long *param0);
*/
int printf_va_68(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2076,8 +2076,8 @@ int scanf_va_69(char const * restrict format, unsigned long long *param0);
*/
int printf_va_69(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2106,8 +2106,8 @@ int scanf_va_70(char const * restrict format, unsigned long long *param0);
*/
int printf_va_70(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2136,8 +2136,8 @@ int scanf_va_71(char const * restrict format, unsigned long long *param0);
*/
int printf_va_71(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2166,8 +2166,8 @@ int scanf_va_72(char const * restrict format, unsigned long long *param0);
*/
int printf_va_72(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2196,8 +2196,8 @@ int scanf_va_73(char const * restrict format, long long *param0);
*/
int printf_va_73(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2226,8 +2226,8 @@ int scanf_va_74(char const * restrict format, long long *param0);
*/
int printf_va_74(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2256,8 +2256,8 @@ int scanf_va_75(char const * restrict format, unsigned long long *param0);
*/
int printf_va_75(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2286,8 +2286,8 @@ int scanf_va_76(char const * restrict format, unsigned long long *param0);
*/
int printf_va_76(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2316,8 +2316,8 @@ int scanf_va_77(char const * restrict format, unsigned long long *param0);
*/
int printf_va_77(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2346,8 +2346,8 @@ int scanf_va_78(char const * restrict format, unsigned long long *param0);
*/
int printf_va_78(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2376,8 +2376,8 @@ int scanf_va_79(char const * restrict format, long *param0);
*/
int printf_va_79(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2406,8 +2406,8 @@ int scanf_va_80(char const * restrict format, long *param0);
*/
int printf_va_80(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2436,8 +2436,8 @@ int scanf_va_81(char const * restrict format, unsigned long *param0);
*/
int printf_va_81(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2466,8 +2466,8 @@ int scanf_va_82(char const * restrict format, unsigned long *param0);
*/
int printf_va_82(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2496,8 +2496,8 @@ int scanf_va_83(char const * restrict format, unsigned long *param0);
*/
int printf_va_83(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
diff --git a/tests/libc/oracle/inttypes_h.4.res.oracle b/tests/libc/oracle/inttypes_h.4.res.oracle
index 90c1f742453f5cefd167915b0b1459fd772289a3..6287272333f1c78e4248b503efdffe9ee805809c 100644
--- a/tests/libc/oracle/inttypes_h.4.res.oracle
+++ b/tests/libc/oracle/inttypes_h.4.res.oracle
@@ -6,8 +6,8 @@
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -36,8 +36,8 @@ int scanf_va_1(char const * restrict format, signed char *param0);
*/
int printf_va_1(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -66,8 +66,8 @@ int scanf_va_2(char const * restrict format, signed char *param0);
*/
int printf_va_2(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -96,8 +96,8 @@ int scanf_va_3(char const * restrict format, unsigned char *param0);
*/
int printf_va_3(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -126,8 +126,8 @@ int scanf_va_4(char const * restrict format, unsigned char *param0);
*/
int printf_va_4(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -156,8 +156,8 @@ int scanf_va_5(char const * restrict format, unsigned char *param0);
*/
int printf_va_5(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -186,8 +186,8 @@ int scanf_va_6(char const * restrict format, unsigned char *param0);
*/
int printf_va_6(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -216,8 +216,8 @@ int scanf_va_7(char const * restrict format, short *param0);
*/
int printf_va_7(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -246,8 +246,8 @@ int scanf_va_8(char const * restrict format, short *param0);
*/
int printf_va_8(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -276,8 +276,8 @@ int scanf_va_9(char const * restrict format, unsigned short *param0);
*/
int printf_va_9(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -306,8 +306,8 @@ int scanf_va_10(char const * restrict format, unsigned short *param0);
*/
int printf_va_10(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -336,8 +336,8 @@ int scanf_va_11(char const * restrict format, unsigned short *param0);
*/
int printf_va_11(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -366,8 +366,8 @@ int scanf_va_12(char const * restrict format, unsigned short *param0);
*/
int printf_va_12(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -396,8 +396,8 @@ int scanf_va_13(char const * restrict format, int *param0);
*/
int printf_va_13(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -426,8 +426,8 @@ int scanf_va_14(char const * restrict format, int *param0);
*/
int printf_va_14(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -456,8 +456,8 @@ int scanf_va_15(char const * restrict format, unsigned int *param0);
*/
int printf_va_15(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -486,8 +486,8 @@ int scanf_va_16(char const * restrict format, unsigned int *param0);
*/
int printf_va_16(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -516,8 +516,8 @@ int scanf_va_17(char const * restrict format, unsigned int *param0);
*/
int printf_va_17(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -546,8 +546,8 @@ int scanf_va_18(char const * restrict format, unsigned int *param0);
*/
int printf_va_18(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -576,8 +576,8 @@ int scanf_va_19(char const * restrict format, long long *param0);
*/
int printf_va_19(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -606,8 +606,8 @@ int scanf_va_20(char const * restrict format, long long *param0);
*/
int printf_va_20(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -636,8 +636,8 @@ int scanf_va_21(char const * restrict format, unsigned long long *param0);
*/
int printf_va_21(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -666,8 +666,8 @@ int scanf_va_22(char const * restrict format, unsigned long long *param0);
*/
int printf_va_22(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -696,8 +696,8 @@ int scanf_va_23(char const * restrict format, unsigned long long *param0);
*/
int printf_va_23(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -726,8 +726,8 @@ int scanf_va_24(char const * restrict format, unsigned long long *param0);
*/
int printf_va_24(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -756,8 +756,8 @@ int scanf_va_25(char const * restrict format, signed char *param0);
*/
int printf_va_25(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -786,8 +786,8 @@ int scanf_va_26(char const * restrict format, signed char *param0);
*/
int printf_va_26(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -816,8 +816,8 @@ int scanf_va_27(char const * restrict format, unsigned char *param0);
*/
int printf_va_27(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -846,8 +846,8 @@ int scanf_va_28(char const * restrict format, unsigned char *param0);
*/
int printf_va_28(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -876,8 +876,8 @@ int scanf_va_29(char const * restrict format, unsigned char *param0);
*/
int printf_va_29(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -906,8 +906,8 @@ int scanf_va_30(char const * restrict format, unsigned char *param0);
*/
int printf_va_30(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -936,8 +936,8 @@ int scanf_va_31(char const * restrict format, short *param0);
*/
int printf_va_31(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -966,8 +966,8 @@ int scanf_va_32(char const * restrict format, short *param0);
*/
int printf_va_32(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -996,8 +996,8 @@ int scanf_va_33(char const * restrict format, unsigned short *param0);
*/
int printf_va_33(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1026,8 +1026,8 @@ int scanf_va_34(char const * restrict format, unsigned short *param0);
*/
int printf_va_34(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1056,8 +1056,8 @@ int scanf_va_35(char const * restrict format, unsigned short *param0);
*/
int printf_va_35(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1086,8 +1086,8 @@ int scanf_va_36(char const * restrict format, unsigned short *param0);
*/
int printf_va_36(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1116,8 +1116,8 @@ int scanf_va_37(char const * restrict format, int *param0);
*/
int printf_va_37(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1146,8 +1146,8 @@ int scanf_va_38(char const * restrict format, int *param0);
*/
int printf_va_38(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1176,8 +1176,8 @@ int scanf_va_39(char const * restrict format, unsigned int *param0);
*/
int printf_va_39(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1206,8 +1206,8 @@ int scanf_va_40(char const * restrict format, unsigned int *param0);
*/
int printf_va_40(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1236,8 +1236,8 @@ int scanf_va_41(char const * restrict format, unsigned int *param0);
*/
int printf_va_41(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1266,8 +1266,8 @@ int scanf_va_42(char const * restrict format, unsigned int *param0);
*/
int printf_va_42(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1296,8 +1296,8 @@ int scanf_va_43(char const * restrict format, long long *param0);
*/
int printf_va_43(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1326,8 +1326,8 @@ int scanf_va_44(char const * restrict format, long long *param0);
*/
int printf_va_44(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1356,8 +1356,8 @@ int scanf_va_45(char const * restrict format, unsigned long long *param0);
*/
int printf_va_45(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1386,8 +1386,8 @@ int scanf_va_46(char const * restrict format, unsigned long long *param0);
*/
int printf_va_46(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1416,8 +1416,8 @@ int scanf_va_47(char const * restrict format, unsigned long long *param0);
*/
int printf_va_47(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1446,8 +1446,8 @@ int scanf_va_48(char const * restrict format, unsigned long long *param0);
*/
int printf_va_48(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1476,8 +1476,8 @@ int scanf_va_49(char const * restrict format, signed char *param0);
*/
int printf_va_49(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1506,8 +1506,8 @@ int scanf_va_50(char const * restrict format, signed char *param0);
*/
int printf_va_50(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1536,8 +1536,8 @@ int scanf_va_51(char const * restrict format, unsigned char *param0);
*/
int printf_va_51(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1566,8 +1566,8 @@ int scanf_va_52(char const * restrict format, unsigned char *param0);
*/
int printf_va_52(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1596,8 +1596,8 @@ int scanf_va_53(char const * restrict format, unsigned char *param0);
*/
int printf_va_53(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1626,8 +1626,8 @@ int scanf_va_54(char const * restrict format, unsigned char *param0);
*/
int printf_va_54(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1656,8 +1656,8 @@ int scanf_va_55(char const * restrict format, int *param0);
*/
int printf_va_55(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1686,8 +1686,8 @@ int scanf_va_56(char const * restrict format, int *param0);
*/
int printf_va_56(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1716,8 +1716,8 @@ int scanf_va_57(char const * restrict format, unsigned int *param0);
*/
int printf_va_57(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1746,8 +1746,8 @@ int scanf_va_58(char const * restrict format, unsigned int *param0);
*/
int printf_va_58(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1776,8 +1776,8 @@ int scanf_va_59(char const * restrict format, unsigned int *param0);
*/
int printf_va_59(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1806,8 +1806,8 @@ int scanf_va_60(char const * restrict format, unsigned int *param0);
*/
int printf_va_60(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1836,8 +1836,8 @@ int scanf_va_61(char const * restrict format, int *param0);
*/
int printf_va_61(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1866,8 +1866,8 @@ int scanf_va_62(char const * restrict format, int *param0);
*/
int printf_va_62(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1896,8 +1896,8 @@ int scanf_va_63(char const * restrict format, unsigned int *param0);
*/
int printf_va_63(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1926,8 +1926,8 @@ int scanf_va_64(char const * restrict format, unsigned int *param0);
*/
int printf_va_64(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1956,8 +1956,8 @@ int scanf_va_65(char const * restrict format, unsigned int *param0);
*/
int printf_va_65(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1986,8 +1986,8 @@ int scanf_va_66(char const * restrict format, unsigned int *param0);
*/
int printf_va_66(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2016,8 +2016,8 @@ int scanf_va_67(char const * restrict format, long long *param0);
*/
int printf_va_67(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2046,8 +2046,8 @@ int scanf_va_68(char const * restrict format, long long *param0);
*/
int printf_va_68(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2076,8 +2076,8 @@ int scanf_va_69(char const * restrict format, unsigned long long *param0);
*/
int printf_va_69(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2106,8 +2106,8 @@ int scanf_va_70(char const * restrict format, unsigned long long *param0);
*/
int printf_va_70(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2136,8 +2136,8 @@ int scanf_va_71(char const * restrict format, unsigned long long *param0);
*/
int printf_va_71(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2166,8 +2166,8 @@ int scanf_va_72(char const * restrict format, unsigned long long *param0);
*/
int printf_va_72(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2196,8 +2196,8 @@ int scanf_va_73(char const * restrict format, long long *param0);
*/
int printf_va_73(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2226,8 +2226,8 @@ int scanf_va_74(char const * restrict format, long long *param0);
*/
int printf_va_74(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2256,8 +2256,8 @@ int scanf_va_75(char const * restrict format, unsigned long long *param0);
*/
int printf_va_75(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2286,8 +2286,8 @@ int scanf_va_76(char const * restrict format, unsigned long long *param0);
*/
int printf_va_76(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2316,8 +2316,8 @@ int scanf_va_77(char const * restrict format, unsigned long long *param0);
*/
int printf_va_77(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2346,8 +2346,8 @@ int scanf_va_78(char const * restrict format, unsigned long long *param0);
*/
int printf_va_78(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2376,8 +2376,8 @@ int scanf_va_79(char const * restrict format, int *param0);
*/
int printf_va_79(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2406,8 +2406,8 @@ int scanf_va_80(char const * restrict format, int *param0);
*/
int printf_va_80(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2436,8 +2436,8 @@ int scanf_va_81(char const * restrict format, unsigned int *param0);
*/
int printf_va_81(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2466,8 +2466,8 @@ int scanf_va_82(char const * restrict format, unsigned int *param0);
*/
int printf_va_82(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2496,8 +2496,8 @@ int scanf_va_83(char const * restrict format, unsigned int *param0);
*/
int printf_va_83(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
diff --git a/tests/libc/oracle/inttypes_h.5.res.oracle b/tests/libc/oracle/inttypes_h.5.res.oracle
index 97acd045fd99a436d4c632a35ca8a2039d37cf52..92e41aa30a46fc7b7c5d20da5e32619e6dea3603 100644
--- a/tests/libc/oracle/inttypes_h.5.res.oracle
+++ b/tests/libc/oracle/inttypes_h.5.res.oracle
@@ -6,8 +6,8 @@
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -36,8 +36,8 @@ int scanf_va_1(char const * restrict format, signed char *param0);
*/
int printf_va_1(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -66,8 +66,8 @@ int scanf_va_2(char const * restrict format, signed char *param0);
*/
int printf_va_2(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -96,8 +96,8 @@ int scanf_va_3(char const * restrict format, unsigned char *param0);
*/
int printf_va_3(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -126,8 +126,8 @@ int scanf_va_4(char const * restrict format, unsigned char *param0);
*/
int printf_va_4(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -156,8 +156,8 @@ int scanf_va_5(char const * restrict format, unsigned char *param0);
*/
int printf_va_5(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -186,8 +186,8 @@ int scanf_va_6(char const * restrict format, unsigned char *param0);
*/
int printf_va_6(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -216,8 +216,8 @@ int scanf_va_7(char const * restrict format, short *param0);
*/
int printf_va_7(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -246,8 +246,8 @@ int scanf_va_8(char const * restrict format, short *param0);
*/
int printf_va_8(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -276,8 +276,8 @@ int scanf_va_9(char const * restrict format, unsigned short *param0);
*/
int printf_va_9(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -306,8 +306,8 @@ int scanf_va_10(char const * restrict format, unsigned short *param0);
*/
int printf_va_10(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -336,8 +336,8 @@ int scanf_va_11(char const * restrict format, unsigned short *param0);
*/
int printf_va_11(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -366,8 +366,8 @@ int scanf_va_12(char const * restrict format, unsigned short *param0);
*/
int printf_va_12(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -396,8 +396,8 @@ int scanf_va_13(char const * restrict format, int *param0);
*/
int printf_va_13(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -426,8 +426,8 @@ int scanf_va_14(char const * restrict format, int *param0);
*/
int printf_va_14(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -456,8 +456,8 @@ int scanf_va_15(char const * restrict format, unsigned int *param0);
*/
int printf_va_15(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -486,8 +486,8 @@ int scanf_va_16(char const * restrict format, unsigned int *param0);
*/
int printf_va_16(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -516,8 +516,8 @@ int scanf_va_17(char const * restrict format, unsigned int *param0);
*/
int printf_va_17(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -546,8 +546,8 @@ int scanf_va_18(char const * restrict format, unsigned int *param0);
*/
int printf_va_18(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -576,8 +576,8 @@ int scanf_va_19(char const * restrict format, long *param0);
*/
int printf_va_19(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -606,8 +606,8 @@ int scanf_va_20(char const * restrict format, long *param0);
*/
int printf_va_20(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -636,8 +636,8 @@ int scanf_va_21(char const * restrict format, unsigned long *param0);
*/
int printf_va_21(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -666,8 +666,8 @@ int scanf_va_22(char const * restrict format, unsigned long *param0);
*/
int printf_va_22(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -696,8 +696,8 @@ int scanf_va_23(char const * restrict format, unsigned long *param0);
*/
int printf_va_23(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -726,8 +726,8 @@ int scanf_va_24(char const * restrict format, unsigned long *param0);
*/
int printf_va_24(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -756,8 +756,8 @@ int scanf_va_25(char const * restrict format, signed char *param0);
*/
int printf_va_25(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -786,8 +786,8 @@ int scanf_va_26(char const * restrict format, signed char *param0);
*/
int printf_va_26(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -816,8 +816,8 @@ int scanf_va_27(char const * restrict format, unsigned char *param0);
*/
int printf_va_27(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -846,8 +846,8 @@ int scanf_va_28(char const * restrict format, unsigned char *param0);
*/
int printf_va_28(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -876,8 +876,8 @@ int scanf_va_29(char const * restrict format, unsigned char *param0);
*/
int printf_va_29(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -906,8 +906,8 @@ int scanf_va_30(char const * restrict format, unsigned char *param0);
*/
int printf_va_30(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -936,8 +936,8 @@ int scanf_va_31(char const * restrict format, short *param0);
*/
int printf_va_31(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -966,8 +966,8 @@ int scanf_va_32(char const * restrict format, short *param0);
*/
int printf_va_32(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -996,8 +996,8 @@ int scanf_va_33(char const * restrict format, unsigned short *param0);
*/
int printf_va_33(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1026,8 +1026,8 @@ int scanf_va_34(char const * restrict format, unsigned short *param0);
*/
int printf_va_34(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1056,8 +1056,8 @@ int scanf_va_35(char const * restrict format, unsigned short *param0);
*/
int printf_va_35(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1086,8 +1086,8 @@ int scanf_va_36(char const * restrict format, unsigned short *param0);
*/
int printf_va_36(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1116,8 +1116,8 @@ int scanf_va_37(char const * restrict format, int *param0);
*/
int printf_va_37(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1146,8 +1146,8 @@ int scanf_va_38(char const * restrict format, int *param0);
*/
int printf_va_38(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1176,8 +1176,8 @@ int scanf_va_39(char const * restrict format, unsigned int *param0);
*/
int printf_va_39(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1206,8 +1206,8 @@ int scanf_va_40(char const * restrict format, unsigned int *param0);
*/
int printf_va_40(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1236,8 +1236,8 @@ int scanf_va_41(char const * restrict format, unsigned int *param0);
*/
int printf_va_41(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1266,8 +1266,8 @@ int scanf_va_42(char const * restrict format, unsigned int *param0);
*/
int printf_va_42(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1296,8 +1296,8 @@ int scanf_va_43(char const * restrict format, long *param0);
*/
int printf_va_43(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1326,8 +1326,8 @@ int scanf_va_44(char const * restrict format, long *param0);
*/
int printf_va_44(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1356,8 +1356,8 @@ int scanf_va_45(char const * restrict format, unsigned long *param0);
*/
int printf_va_45(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1386,8 +1386,8 @@ int scanf_va_46(char const * restrict format, unsigned long *param0);
*/
int printf_va_46(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1416,8 +1416,8 @@ int scanf_va_47(char const * restrict format, unsigned long *param0);
*/
int printf_va_47(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1446,8 +1446,8 @@ int scanf_va_48(char const * restrict format, unsigned long *param0);
*/
int printf_va_48(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1476,8 +1476,8 @@ int scanf_va_49(char const * restrict format, signed char *param0);
*/
int printf_va_49(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1506,8 +1506,8 @@ int scanf_va_50(char const * restrict format, signed char *param0);
*/
int printf_va_50(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1536,8 +1536,8 @@ int scanf_va_51(char const * restrict format, unsigned char *param0);
*/
int printf_va_51(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1566,8 +1566,8 @@ int scanf_va_52(char const * restrict format, unsigned char *param0);
*/
int printf_va_52(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1596,8 +1596,8 @@ int scanf_va_53(char const * restrict format, unsigned char *param0);
*/
int printf_va_53(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1626,8 +1626,8 @@ int scanf_va_54(char const * restrict format, unsigned char *param0);
*/
int printf_va_54(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1656,8 +1656,8 @@ int scanf_va_55(char const * restrict format, int *param0);
*/
int printf_va_55(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1686,8 +1686,8 @@ int scanf_va_56(char const * restrict format, int *param0);
*/
int printf_va_56(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1716,8 +1716,8 @@ int scanf_va_57(char const * restrict format, unsigned int *param0);
*/
int printf_va_57(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1746,8 +1746,8 @@ int scanf_va_58(char const * restrict format, unsigned int *param0);
*/
int printf_va_58(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1776,8 +1776,8 @@ int scanf_va_59(char const * restrict format, unsigned int *param0);
*/
int printf_va_59(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1806,8 +1806,8 @@ int scanf_va_60(char const * restrict format, unsigned int *param0);
*/
int printf_va_60(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1836,8 +1836,8 @@ int scanf_va_61(char const * restrict format, int *param0);
*/
int printf_va_61(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1866,8 +1866,8 @@ int scanf_va_62(char const * restrict format, int *param0);
*/
int printf_va_62(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1896,8 +1896,8 @@ int scanf_va_63(char const * restrict format, unsigned int *param0);
*/
int printf_va_63(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1926,8 +1926,8 @@ int scanf_va_64(char const * restrict format, unsigned int *param0);
*/
int printf_va_64(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1956,8 +1956,8 @@ int scanf_va_65(char const * restrict format, unsigned int *param0);
*/
int printf_va_65(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1986,8 +1986,8 @@ int scanf_va_66(char const * restrict format, unsigned int *param0);
*/
int printf_va_66(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2016,8 +2016,8 @@ int scanf_va_67(char const * restrict format, long *param0);
*/
int printf_va_67(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2046,8 +2046,8 @@ int scanf_va_68(char const * restrict format, long *param0);
*/
int printf_va_68(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2076,8 +2076,8 @@ int scanf_va_69(char const * restrict format, unsigned long *param0);
*/
int printf_va_69(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2106,8 +2106,8 @@ int scanf_va_70(char const * restrict format, unsigned long *param0);
*/
int printf_va_70(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2136,8 +2136,8 @@ int scanf_va_71(char const * restrict format, unsigned long *param0);
*/
int printf_va_71(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2166,8 +2166,8 @@ int scanf_va_72(char const * restrict format, unsigned long *param0);
*/
int printf_va_72(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2196,8 +2196,8 @@ int scanf_va_73(char const * restrict format, long long *param0);
*/
int printf_va_73(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2226,8 +2226,8 @@ int scanf_va_74(char const * restrict format, long long *param0);
*/
int printf_va_74(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2256,8 +2256,8 @@ int scanf_va_75(char const * restrict format, unsigned long long *param0);
*/
int printf_va_75(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2286,8 +2286,8 @@ int scanf_va_76(char const * restrict format, unsigned long long *param0);
*/
int printf_va_76(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2316,8 +2316,8 @@ int scanf_va_77(char const * restrict format, unsigned long long *param0);
*/
int printf_va_77(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2346,8 +2346,8 @@ int scanf_va_78(char const * restrict format, unsigned long long *param0);
*/
int printf_va_78(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2376,8 +2376,8 @@ int scanf_va_79(char const * restrict format, long *param0);
*/
int printf_va_79(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2406,8 +2406,8 @@ int scanf_va_80(char const * restrict format, long *param0);
*/
int printf_va_80(char const * restrict format, long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2436,8 +2436,8 @@ int scanf_va_81(char const * restrict format, unsigned long *param0);
*/
int printf_va_81(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2466,8 +2466,8 @@ int scanf_va_82(char const * restrict format, unsigned long *param0);
*/
int printf_va_82(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2496,8 +2496,8 @@ int scanf_va_83(char const * restrict format, unsigned long *param0);
*/
int printf_va_83(char const * restrict format, unsigned long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
diff --git a/tests/libc/oracle/inttypes_h.6.res.oracle b/tests/libc/oracle/inttypes_h.6.res.oracle
index 90c1f742453f5cefd167915b0b1459fd772289a3..6287272333f1c78e4248b503efdffe9ee805809c 100644
--- a/tests/libc/oracle/inttypes_h.6.res.oracle
+++ b/tests/libc/oracle/inttypes_h.6.res.oracle
@@ -6,8 +6,8 @@
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -36,8 +36,8 @@ int scanf_va_1(char const * restrict format, signed char *param0);
*/
int printf_va_1(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -66,8 +66,8 @@ int scanf_va_2(char const * restrict format, signed char *param0);
*/
int printf_va_2(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -96,8 +96,8 @@ int scanf_va_3(char const * restrict format, unsigned char *param0);
*/
int printf_va_3(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -126,8 +126,8 @@ int scanf_va_4(char const * restrict format, unsigned char *param0);
*/
int printf_va_4(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -156,8 +156,8 @@ int scanf_va_5(char const * restrict format, unsigned char *param0);
*/
int printf_va_5(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -186,8 +186,8 @@ int scanf_va_6(char const * restrict format, unsigned char *param0);
*/
int printf_va_6(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -216,8 +216,8 @@ int scanf_va_7(char const * restrict format, short *param0);
*/
int printf_va_7(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -246,8 +246,8 @@ int scanf_va_8(char const * restrict format, short *param0);
*/
int printf_va_8(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -276,8 +276,8 @@ int scanf_va_9(char const * restrict format, unsigned short *param0);
*/
int printf_va_9(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -306,8 +306,8 @@ int scanf_va_10(char const * restrict format, unsigned short *param0);
*/
int printf_va_10(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -336,8 +336,8 @@ int scanf_va_11(char const * restrict format, unsigned short *param0);
*/
int printf_va_11(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -366,8 +366,8 @@ int scanf_va_12(char const * restrict format, unsigned short *param0);
*/
int printf_va_12(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -396,8 +396,8 @@ int scanf_va_13(char const * restrict format, int *param0);
*/
int printf_va_13(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -426,8 +426,8 @@ int scanf_va_14(char const * restrict format, int *param0);
*/
int printf_va_14(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -456,8 +456,8 @@ int scanf_va_15(char const * restrict format, unsigned int *param0);
*/
int printf_va_15(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -486,8 +486,8 @@ int scanf_va_16(char const * restrict format, unsigned int *param0);
*/
int printf_va_16(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -516,8 +516,8 @@ int scanf_va_17(char const * restrict format, unsigned int *param0);
*/
int printf_va_17(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -546,8 +546,8 @@ int scanf_va_18(char const * restrict format, unsigned int *param0);
*/
int printf_va_18(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -576,8 +576,8 @@ int scanf_va_19(char const * restrict format, long long *param0);
*/
int printf_va_19(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -606,8 +606,8 @@ int scanf_va_20(char const * restrict format, long long *param0);
*/
int printf_va_20(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -636,8 +636,8 @@ int scanf_va_21(char const * restrict format, unsigned long long *param0);
*/
int printf_va_21(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -666,8 +666,8 @@ int scanf_va_22(char const * restrict format, unsigned long long *param0);
*/
int printf_va_22(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -696,8 +696,8 @@ int scanf_va_23(char const * restrict format, unsigned long long *param0);
*/
int printf_va_23(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -726,8 +726,8 @@ int scanf_va_24(char const * restrict format, unsigned long long *param0);
*/
int printf_va_24(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -756,8 +756,8 @@ int scanf_va_25(char const * restrict format, signed char *param0);
*/
int printf_va_25(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -786,8 +786,8 @@ int scanf_va_26(char const * restrict format, signed char *param0);
*/
int printf_va_26(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -816,8 +816,8 @@ int scanf_va_27(char const * restrict format, unsigned char *param0);
*/
int printf_va_27(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -846,8 +846,8 @@ int scanf_va_28(char const * restrict format, unsigned char *param0);
*/
int printf_va_28(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -876,8 +876,8 @@ int scanf_va_29(char const * restrict format, unsigned char *param0);
*/
int printf_va_29(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -906,8 +906,8 @@ int scanf_va_30(char const * restrict format, unsigned char *param0);
*/
int printf_va_30(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -936,8 +936,8 @@ int scanf_va_31(char const * restrict format, short *param0);
*/
int printf_va_31(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -966,8 +966,8 @@ int scanf_va_32(char const * restrict format, short *param0);
*/
int printf_va_32(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -996,8 +996,8 @@ int scanf_va_33(char const * restrict format, unsigned short *param0);
*/
int printf_va_33(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1026,8 +1026,8 @@ int scanf_va_34(char const * restrict format, unsigned short *param0);
*/
int printf_va_34(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1056,8 +1056,8 @@ int scanf_va_35(char const * restrict format, unsigned short *param0);
*/
int printf_va_35(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1086,8 +1086,8 @@ int scanf_va_36(char const * restrict format, unsigned short *param0);
*/
int printf_va_36(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1116,8 +1116,8 @@ int scanf_va_37(char const * restrict format, int *param0);
*/
int printf_va_37(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1146,8 +1146,8 @@ int scanf_va_38(char const * restrict format, int *param0);
*/
int printf_va_38(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1176,8 +1176,8 @@ int scanf_va_39(char const * restrict format, unsigned int *param0);
*/
int printf_va_39(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1206,8 +1206,8 @@ int scanf_va_40(char const * restrict format, unsigned int *param0);
*/
int printf_va_40(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1236,8 +1236,8 @@ int scanf_va_41(char const * restrict format, unsigned int *param0);
*/
int printf_va_41(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1266,8 +1266,8 @@ int scanf_va_42(char const * restrict format, unsigned int *param0);
*/
int printf_va_42(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1296,8 +1296,8 @@ int scanf_va_43(char const * restrict format, long long *param0);
*/
int printf_va_43(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1326,8 +1326,8 @@ int scanf_va_44(char const * restrict format, long long *param0);
*/
int printf_va_44(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1356,8 +1356,8 @@ int scanf_va_45(char const * restrict format, unsigned long long *param0);
*/
int printf_va_45(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1386,8 +1386,8 @@ int scanf_va_46(char const * restrict format, unsigned long long *param0);
*/
int printf_va_46(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1416,8 +1416,8 @@ int scanf_va_47(char const * restrict format, unsigned long long *param0);
*/
int printf_va_47(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1446,8 +1446,8 @@ int scanf_va_48(char const * restrict format, unsigned long long *param0);
*/
int printf_va_48(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1476,8 +1476,8 @@ int scanf_va_49(char const * restrict format, signed char *param0);
*/
int printf_va_49(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1506,8 +1506,8 @@ int scanf_va_50(char const * restrict format, signed char *param0);
*/
int printf_va_50(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1536,8 +1536,8 @@ int scanf_va_51(char const * restrict format, unsigned char *param0);
*/
int printf_va_51(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1566,8 +1566,8 @@ int scanf_va_52(char const * restrict format, unsigned char *param0);
*/
int printf_va_52(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1596,8 +1596,8 @@ int scanf_va_53(char const * restrict format, unsigned char *param0);
*/
int printf_va_53(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1626,8 +1626,8 @@ int scanf_va_54(char const * restrict format, unsigned char *param0);
*/
int printf_va_54(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1656,8 +1656,8 @@ int scanf_va_55(char const * restrict format, int *param0);
*/
int printf_va_55(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1686,8 +1686,8 @@ int scanf_va_56(char const * restrict format, int *param0);
*/
int printf_va_56(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1716,8 +1716,8 @@ int scanf_va_57(char const * restrict format, unsigned int *param0);
*/
int printf_va_57(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1746,8 +1746,8 @@ int scanf_va_58(char const * restrict format, unsigned int *param0);
*/
int printf_va_58(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1776,8 +1776,8 @@ int scanf_va_59(char const * restrict format, unsigned int *param0);
*/
int printf_va_59(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1806,8 +1806,8 @@ int scanf_va_60(char const * restrict format, unsigned int *param0);
*/
int printf_va_60(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1836,8 +1836,8 @@ int scanf_va_61(char const * restrict format, int *param0);
*/
int printf_va_61(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1866,8 +1866,8 @@ int scanf_va_62(char const * restrict format, int *param0);
*/
int printf_va_62(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1896,8 +1896,8 @@ int scanf_va_63(char const * restrict format, unsigned int *param0);
*/
int printf_va_63(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1926,8 +1926,8 @@ int scanf_va_64(char const * restrict format, unsigned int *param0);
*/
int printf_va_64(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1956,8 +1956,8 @@ int scanf_va_65(char const * restrict format, unsigned int *param0);
*/
int printf_va_65(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1986,8 +1986,8 @@ int scanf_va_66(char const * restrict format, unsigned int *param0);
*/
int printf_va_66(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2016,8 +2016,8 @@ int scanf_va_67(char const * restrict format, long long *param0);
*/
int printf_va_67(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2046,8 +2046,8 @@ int scanf_va_68(char const * restrict format, long long *param0);
*/
int printf_va_68(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2076,8 +2076,8 @@ int scanf_va_69(char const * restrict format, unsigned long long *param0);
*/
int printf_va_69(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2106,8 +2106,8 @@ int scanf_va_70(char const * restrict format, unsigned long long *param0);
*/
int printf_va_70(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2136,8 +2136,8 @@ int scanf_va_71(char const * restrict format, unsigned long long *param0);
*/
int printf_va_71(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2166,8 +2166,8 @@ int scanf_va_72(char const * restrict format, unsigned long long *param0);
*/
int printf_va_72(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2196,8 +2196,8 @@ int scanf_va_73(char const * restrict format, long long *param0);
*/
int printf_va_73(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2226,8 +2226,8 @@ int scanf_va_74(char const * restrict format, long long *param0);
*/
int printf_va_74(char const * restrict format, long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2256,8 +2256,8 @@ int scanf_va_75(char const * restrict format, unsigned long long *param0);
*/
int printf_va_75(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2286,8 +2286,8 @@ int scanf_va_76(char const * restrict format, unsigned long long *param0);
*/
int printf_va_76(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2316,8 +2316,8 @@ int scanf_va_77(char const * restrict format, unsigned long long *param0);
*/
int printf_va_77(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2346,8 +2346,8 @@ int scanf_va_78(char const * restrict format, unsigned long long *param0);
*/
int printf_va_78(char const * restrict format, unsigned long long param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2376,8 +2376,8 @@ int scanf_va_79(char const * restrict format, int *param0);
*/
int printf_va_79(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2406,8 +2406,8 @@ int scanf_va_80(char const * restrict format, int *param0);
*/
int printf_va_80(char const * restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2436,8 +2436,8 @@ int scanf_va_81(char const * restrict format, unsigned int *param0);
*/
int printf_va_81(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2466,8 +2466,8 @@ int scanf_va_82(char const * restrict format, unsigned int *param0);
*/
int printf_va_82(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2496,8 +2496,8 @@ int scanf_va_83(char const * restrict format, unsigned int *param0);
*/
int printf_va_83(char const * restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
diff --git a/tests/libc/oracle/inttypes_h.7.res.oracle b/tests/libc/oracle/inttypes_h.7.res.oracle
index 9dfd0ff2a95812c13da5604d8372e79fd9a2882b..65e7c8f854bdbe12b1239a4877d239440426f4f4 100644
--- a/tests/libc/oracle/inttypes_h.7.res.oracle
+++ b/tests/libc/oracle/inttypes_h.7.res.oracle
@@ -6,8 +6,8 @@
#include "stddef.h"
#include "stdint.h"
#include "stdio.h"
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -36,8 +36,8 @@ int scanf_va_1(char const * __restrict format, signed char *param0);
*/
int printf_va_1(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -66,8 +66,8 @@ int scanf_va_2(char const * __restrict format, signed char *param0);
*/
int printf_va_2(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -96,8 +96,8 @@ int scanf_va_3(char const * __restrict format, unsigned char *param0);
*/
int printf_va_3(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -126,8 +126,8 @@ int scanf_va_4(char const * __restrict format, unsigned char *param0);
*/
int printf_va_4(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -156,8 +156,8 @@ int scanf_va_5(char const * __restrict format, unsigned char *param0);
*/
int printf_va_5(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -186,8 +186,8 @@ int scanf_va_6(char const * __restrict format, unsigned char *param0);
*/
int printf_va_6(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -216,8 +216,8 @@ int scanf_va_7(char const * __restrict format, short *param0);
*/
int printf_va_7(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -246,8 +246,8 @@ int scanf_va_8(char const * __restrict format, short *param0);
*/
int printf_va_8(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -276,8 +276,8 @@ int scanf_va_9(char const * __restrict format, unsigned short *param0);
*/
int printf_va_9(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -306,8 +306,8 @@ int scanf_va_10(char const * __restrict format, unsigned short *param0);
*/
int printf_va_10(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -336,8 +336,8 @@ int scanf_va_11(char const * __restrict format, unsigned short *param0);
*/
int printf_va_11(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -366,8 +366,8 @@ int scanf_va_12(char const * __restrict format, unsigned short *param0);
*/
int printf_va_12(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -396,8 +396,8 @@ int scanf_va_13(char const * __restrict format, int *param0);
*/
int printf_va_13(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -426,8 +426,8 @@ int scanf_va_14(char const * __restrict format, int *param0);
*/
int printf_va_14(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -456,8 +456,8 @@ int scanf_va_15(char const * __restrict format, unsigned int *param0);
*/
int printf_va_15(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -486,8 +486,8 @@ int scanf_va_16(char const * __restrict format, unsigned int *param0);
*/
int printf_va_16(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -516,8 +516,8 @@ int scanf_va_17(char const * __restrict format, unsigned int *param0);
*/
int printf_va_17(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -546,8 +546,8 @@ int scanf_va_18(char const * __restrict format, unsigned int *param0);
*/
int printf_va_18(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -576,8 +576,8 @@ int scanf_va_19(char const * __restrict format, __int64 *param0);
*/
int printf_va_19(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -606,8 +606,8 @@ int scanf_va_20(char const * __restrict format, __int64 *param0);
*/
int printf_va_20(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -636,8 +636,8 @@ int scanf_va_21(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_21(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -666,8 +666,8 @@ int scanf_va_22(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_22(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -696,8 +696,8 @@ int scanf_va_23(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_23(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -726,8 +726,8 @@ int scanf_va_24(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_24(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -756,8 +756,8 @@ int scanf_va_25(char const * __restrict format, signed char *param0);
*/
int printf_va_25(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -786,8 +786,8 @@ int scanf_va_26(char const * __restrict format, signed char *param0);
*/
int printf_va_26(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -816,8 +816,8 @@ int scanf_va_27(char const * __restrict format, unsigned char *param0);
*/
int printf_va_27(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -846,8 +846,8 @@ int scanf_va_28(char const * __restrict format, unsigned char *param0);
*/
int printf_va_28(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -876,8 +876,8 @@ int scanf_va_29(char const * __restrict format, unsigned char *param0);
*/
int printf_va_29(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -906,8 +906,8 @@ int scanf_va_30(char const * __restrict format, unsigned char *param0);
*/
int printf_va_30(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -936,8 +936,8 @@ int scanf_va_31(char const * __restrict format, short *param0);
*/
int printf_va_31(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -966,8 +966,8 @@ int scanf_va_32(char const * __restrict format, short *param0);
*/
int printf_va_32(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -996,8 +996,8 @@ int scanf_va_33(char const * __restrict format, unsigned short *param0);
*/
int printf_va_33(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1026,8 +1026,8 @@ int scanf_va_34(char const * __restrict format, unsigned short *param0);
*/
int printf_va_34(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1056,8 +1056,8 @@ int scanf_va_35(char const * __restrict format, unsigned short *param0);
*/
int printf_va_35(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1086,8 +1086,8 @@ int scanf_va_36(char const * __restrict format, unsigned short *param0);
*/
int printf_va_36(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1116,8 +1116,8 @@ int scanf_va_37(char const * __restrict format, int *param0);
*/
int printf_va_37(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1146,8 +1146,8 @@ int scanf_va_38(char const * __restrict format, int *param0);
*/
int printf_va_38(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1176,8 +1176,8 @@ int scanf_va_39(char const * __restrict format, unsigned int *param0);
*/
int printf_va_39(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1206,8 +1206,8 @@ int scanf_va_40(char const * __restrict format, unsigned int *param0);
*/
int printf_va_40(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1236,8 +1236,8 @@ int scanf_va_41(char const * __restrict format, unsigned int *param0);
*/
int printf_va_41(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1266,8 +1266,8 @@ int scanf_va_42(char const * __restrict format, unsigned int *param0);
*/
int printf_va_42(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1296,8 +1296,8 @@ int scanf_va_43(char const * __restrict format, __int64 *param0);
*/
int printf_va_43(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1326,8 +1326,8 @@ int scanf_va_44(char const * __restrict format, __int64 *param0);
*/
int printf_va_44(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1356,8 +1356,8 @@ int scanf_va_45(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_45(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1386,8 +1386,8 @@ int scanf_va_46(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_46(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1416,8 +1416,8 @@ int scanf_va_47(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_47(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1446,8 +1446,8 @@ int scanf_va_48(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_48(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1476,8 +1476,8 @@ int scanf_va_49(char const * __restrict format, signed char *param0);
*/
int printf_va_49(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1506,8 +1506,8 @@ int scanf_va_50(char const * __restrict format, signed char *param0);
*/
int printf_va_50(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1536,8 +1536,8 @@ int scanf_va_51(char const * __restrict format, unsigned char *param0);
*/
int printf_va_51(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1566,8 +1566,8 @@ int scanf_va_52(char const * __restrict format, unsigned char *param0);
*/
int printf_va_52(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1596,8 +1596,8 @@ int scanf_va_53(char const * __restrict format, unsigned char *param0);
*/
int printf_va_53(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1626,8 +1626,8 @@ int scanf_va_54(char const * __restrict format, unsigned char *param0);
*/
int printf_va_54(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1656,8 +1656,8 @@ int scanf_va_55(char const * __restrict format, int *param0);
*/
int printf_va_55(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1686,8 +1686,8 @@ int scanf_va_56(char const * __restrict format, int *param0);
*/
int printf_va_56(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1716,8 +1716,8 @@ int scanf_va_57(char const * __restrict format, unsigned int *param0);
*/
int printf_va_57(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1746,8 +1746,8 @@ int scanf_va_58(char const * __restrict format, unsigned int *param0);
*/
int printf_va_58(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1776,8 +1776,8 @@ int scanf_va_59(char const * __restrict format, unsigned int *param0);
*/
int printf_va_59(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1806,8 +1806,8 @@ int scanf_va_60(char const * __restrict format, unsigned int *param0);
*/
int printf_va_60(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1836,8 +1836,8 @@ int scanf_va_61(char const * __restrict format, int *param0);
*/
int printf_va_61(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1866,8 +1866,8 @@ int scanf_va_62(char const * __restrict format, int *param0);
*/
int printf_va_62(char const * __restrict format, int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1896,8 +1896,8 @@ int scanf_va_63(char const * __restrict format, unsigned int *param0);
*/
int printf_va_63(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1926,8 +1926,8 @@ int scanf_va_64(char const * __restrict format, unsigned int *param0);
*/
int printf_va_64(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1956,8 +1956,8 @@ int scanf_va_65(char const * __restrict format, unsigned int *param0);
*/
int printf_va_65(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -1986,8 +1986,8 @@ int scanf_va_66(char const * __restrict format, unsigned int *param0);
*/
int printf_va_66(char const * __restrict format, unsigned int param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2016,8 +2016,8 @@ int scanf_va_67(char const * __restrict format, __int64 *param0);
*/
int printf_va_67(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2046,8 +2046,8 @@ int scanf_va_68(char const * __restrict format, __int64 *param0);
*/
int printf_va_68(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2076,8 +2076,8 @@ int scanf_va_69(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_69(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2106,8 +2106,8 @@ int scanf_va_70(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_70(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2136,8 +2136,8 @@ int scanf_va_71(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_71(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2166,8 +2166,8 @@ int scanf_va_72(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_72(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2196,8 +2196,8 @@ int scanf_va_73(char const * __restrict format, __int64 *param0);
*/
int printf_va_73(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2226,8 +2226,8 @@ int scanf_va_74(char const * __restrict format, __int64 *param0);
*/
int printf_va_74(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2256,8 +2256,8 @@ int scanf_va_75(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_75(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2286,8 +2286,8 @@ int scanf_va_76(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_76(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2316,8 +2316,8 @@ int scanf_va_77(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_77(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2346,8 +2346,8 @@ int scanf_va_78(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_78(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2376,8 +2376,8 @@ int scanf_va_79(char const * __restrict format, __int64 *param0);
*/
int printf_va_79(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2406,8 +2406,8 @@ int scanf_va_80(char const * __restrict format, __int64 *param0);
*/
int printf_va_80(char const * __restrict format, __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2436,8 +2436,8 @@ int scanf_va_81(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_81(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2466,8 +2466,8 @@ int scanf_va_82(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_82(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
@@ -2496,8 +2496,8 @@ int scanf_va_83(char const * __restrict format, unsigned __int64 *param0);
*/
int printf_va_83(char const * __restrict format, unsigned __int64 param0);
-/*@ requires valid_read_string(format);
- requires \valid(param0);
+/*@ requires \valid(param0);
+ requires valid_read_string(format);
ensures \initialized(param0);
assigns \result, __fc_stdin->__fc_FILE_data, *param0;
assigns \result
diff --git a/tests/libc/oracle/netdb_c.res.oracle b/tests/libc/oracle/netdb_c.res.oracle
index 9a9d6d24921562fb1b27ac6e9b243bb85fe834aa..dcce9e252a9bb2f80e23d8ed6ce71e674d87a838 100644
--- a/tests/libc/oracle/netdb_c.res.oracle
+++ b/tests/libc/oracle/netdb_c.res.oracle
@@ -148,10 +148,10 @@
[eva] computing for function fprintf_va_1 <- main.
Called from tests/libc/netdb_c.c:36.
[eva] using specification for function fprintf_va_1
-[eva] tests/libc/netdb_c.c:36:
- function fprintf_va_1: precondition valid_read_string(format) got status valid.
[eva] tests/libc/netdb_c.c:36:
function fprintf_va_1: precondition valid_read_string(param0) got status valid.
+[eva] tests/libc/netdb_c.c:36:
+ function fprintf_va_1: precondition valid_read_string(format) got status valid.
[eva] Done for function fprintf_va_1
[eva] computing for function exit <- main.
Called from tests/libc/netdb_c.c:37.
diff --git a/tests/libc/oracle/netinet_in_h.res.oracle b/tests/libc/oracle/netinet_in_h.res.oracle
index a8fa5453586f36f4e871c4dd82be2f2df0d85e3c..1215b249e2e9331284a6ab6fe66d38ff739ec05e 100644
--- a/tests/libc/oracle/netinet_in_h.res.oracle
+++ b/tests/libc/oracle/netinet_in_h.res.oracle
@@ -11,10 +11,10 @@
[eva] computing for function printf_va_1 <- main.
Called from tests/libc/netinet_in_h.c:6.
[eva] using specification for function printf_va_1
-[eva] tests/libc/netinet_in_h.c:6:
- function printf_va_1: precondition valid_read_string(format) got status valid.
[eva] tests/libc/netinet_in_h.c:6:
function printf_va_1: precondition valid_read_string(param0) got status valid.
+[eva] tests/libc/netinet_in_h.c:6:
+ function printf_va_1: precondition valid_read_string(format) got status valid.
[eva] Done for function printf_va_1
[eva] Recording results for main
[eva] done for function main
diff --git a/tests/libc/oracle/socket.0.res.oracle b/tests/libc/oracle/socket.0.res.oracle
index d3cbc6849dd201722a97d1d88416911658cff675..02ea91c38a587f467ef5ed8466820b2ed78645ae 100644
--- a/tests/libc/oracle/socket.0.res.oracle
+++ b/tests/libc/oracle/socket.0.res.oracle
@@ -59,10 +59,10 @@
[eva] computing for function printf_va_1 <- test_read <- main.
Called from tests/libc/socket.c:62.
[eva] using specification for function printf_va_1
-[eva] tests/libc/socket.c:62:
- function printf_va_1: precondition valid_read_string(format) got status valid.
[eva:alarm] tests/libc/socket.c:62: Warning:
function printf_va_1: precondition valid_read_string(param0) got status unknown.
+[eva] tests/libc/socket.c:62:
+ function printf_va_1: precondition valid_read_string(format) got status valid.
[eva] Done for function printf_va_1
[eva] Recording results for test_read
[eva] Done for function test_read
@@ -93,12 +93,12 @@
[eva] computing for function printf_va_2 <- test_readv <- main.
Called from tests/libc/socket.c:75.
[eva] using specification for function printf_va_2
-[eva] tests/libc/socket.c:75:
- function printf_va_2: precondition valid_read_string(format) got status valid.
-[eva:alarm] tests/libc/socket.c:75: Warning:
- function printf_va_2: precondition valid_read_nstring(param1, 3) got status unknown.
[eva:alarm] tests/libc/socket.c:75: Warning:
function printf_va_2: precondition valid_read_nstring(param0, 2) got status unknown.
+[eva:alarm] tests/libc/socket.c:75: Warning:
+ function printf_va_2: precondition valid_read_nstring(param1, 3) got status unknown.
+[eva] tests/libc/socket.c:75:
+ function printf_va_2: precondition valid_read_string(format) got status valid.
[eva] Done for function printf_va_2
[eva] Recording results for test_readv
[eva] Done for function test_readv
@@ -123,12 +123,12 @@
[eva] computing for function printf_va_3 <- test_recvmsg <- main.
Called from tests/libc/socket.c:95.
[eva] using specification for function printf_va_3
-[eva] tests/libc/socket.c:95:
- function printf_va_3: precondition valid_read_string(format) got status valid.
-[eva:alarm] tests/libc/socket.c:95: Warning:
- function printf_va_3: precondition valid_read_nstring(param1, 3) got status unknown.
[eva:alarm] tests/libc/socket.c:95: Warning:
function printf_va_3: precondition valid_read_nstring(param0, 2) got status unknown.
+[eva:alarm] tests/libc/socket.c:95: Warning:
+ function printf_va_3: precondition valid_read_nstring(param1, 3) got status unknown.
+[eva] tests/libc/socket.c:95:
+ function printf_va_3: precondition valid_read_string(format) got status valid.
[eva] Done for function printf_va_3
[eva] Recording results for test_recvmsg
[eva] Done for function test_recvmsg
diff --git a/tests/libc/oracle/socket.1.res.oracle b/tests/libc/oracle/socket.1.res.oracle
index eb0bfef77cb0ccd765bf162598cac8399cb3dbbf..b20c456d6a35250afb73bcd9284f7990ba95e33f 100644
--- a/tests/libc/oracle/socket.1.res.oracle
+++ b/tests/libc/oracle/socket.1.res.oracle
@@ -59,10 +59,10 @@
[eva] computing for function printf_va_1 <- test_read <- main.
Called from tests/libc/socket.c:62.
[eva] using specification for function printf_va_1
-[eva] tests/libc/socket.c:62:
- function printf_va_1: precondition valid_read_string(format) got status valid.
[eva:alarm] tests/libc/socket.c:62: Warning:
function printf_va_1: precondition valid_read_string(param0) got status unknown.
+[eva] tests/libc/socket.c:62:
+ function printf_va_1: precondition valid_read_string(format) got status valid.
[eva] Done for function printf_va_1
[eva] Recording results for test_read
[eva] Done for function test_read
@@ -93,12 +93,12 @@
[eva] computing for function printf_va_2 <- test_readv <- main.
Called from tests/libc/socket.c:75.
[eva] using specification for function printf_va_2
-[eva] tests/libc/socket.c:75:
- function printf_va_2: precondition valid_read_string(format) got status valid.
-[eva:alarm] tests/libc/socket.c:75: Warning:
- function printf_va_2: precondition valid_read_nstring(param1, 3) got status unknown.
[eva:alarm] tests/libc/socket.c:75: Warning:
function printf_va_2: precondition valid_read_nstring(param0, 2) got status unknown.
+[eva:alarm] tests/libc/socket.c:75: Warning:
+ function printf_va_2: precondition valid_read_nstring(param1, 3) got status unknown.
+[eva] tests/libc/socket.c:75:
+ function printf_va_2: precondition valid_read_string(format) got status valid.
[eva] Done for function printf_va_2
[eva] Recording results for test_readv
[eva] Done for function test_readv
@@ -123,12 +123,12 @@
[eva] computing for function printf_va_3 <- test_recvmsg <- main.
Called from tests/libc/socket.c:95.
[eva] using specification for function printf_va_3
-[eva] tests/libc/socket.c:95:
- function printf_va_3: precondition valid_read_string(format) got status valid.
-[eva:alarm] tests/libc/socket.c:95: Warning:
- function printf_va_3: precondition valid_read_nstring(param1, 3) got status unknown.
[eva:alarm] tests/libc/socket.c:95: Warning:
function printf_va_3: precondition valid_read_nstring(param0, 2) got status unknown.
+[eva:alarm] tests/libc/socket.c:95: Warning:
+ function printf_va_3: precondition valid_read_nstring(param1, 3) got status unknown.
+[eva] tests/libc/socket.c:95:
+ function printf_va_3: precondition valid_read_string(format) got status valid.
[eva] Done for function printf_va_3
[eva] Recording results for test_recvmsg
[eva] Done for function test_recvmsg
diff --git a/tests/syntax/oracle/copy_visitor_bts_1073.0.res.oracle b/tests/syntax/oracle/copy_visitor_bts_1073.0.res.oracle
index 4e7341fa2833882844f02a7c4cec89db51521178..52bda4e41dd0c3ec64738ef4573ffae4a0d0bd01 100644
--- a/tests/syntax/oracle/copy_visitor_bts_1073.0.res.oracle
+++ b/tests/syntax/oracle/copy_visitor_bts_1073.0.res.oracle
@@ -42,8 +42,8 @@ int g1(int y)
*/
int printf_va_1(char const * restrict format);
-/*@ requires valid_read_string(format);
- requires valid_read_string(param1);
+/*@ requires valid_read_string(param1);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
diff --git a/tests/syntax/oracle/copy_visitor_bts_1073.1.res.oracle b/tests/syntax/oracle/copy_visitor_bts_1073.1.res.oracle
index 07068fa6a84f601508956deea91c33274fc2b04d..5fefd6a66162609554426a03a604eebcf2f22261 100644
--- a/tests/syntax/oracle/copy_visitor_bts_1073.1.res.oracle
+++ b/tests/syntax/oracle/copy_visitor_bts_1073.1.res.oracle
@@ -32,8 +32,8 @@ int g(int y)
*/
int printf_va_1(char const * restrict format);
-/*@ requires valid_read_string(format);
- requires valid_read_string(param1);
+/*@ requires valid_read_string(param1);
+ requires valid_read_string(format);
assigns \result, __fc_stdout->__fc_FILE_data;
assigns \result
\from (indirect: __fc_stdout->__fc_FILE_id),
diff --git a/tests/value/oracle/cert_exp35_c.res.oracle b/tests/value/oracle/cert_exp35_c.res.oracle
index a7a780f57972b4f743c0d4094e1b3b0d2ac55d82..18cbaa8b9d957f6fec96663cc5429f5cc2233f70 100644
--- a/tests/value/oracle/cert_exp35_c.res.oracle
+++ b/tests/value/oracle/cert_exp35_c.res.oracle
@@ -12,10 +12,10 @@
[eva] computing for function printf_va_1 <- main.
Called from tests/value/cert_exp35_c.i:24.
[eva] using specification for function printf_va_1
-[eva:alarm] tests/value/cert_exp35_c.i:24: Warning:
- function printf_va_1: precondition valid_read_string(format) got status unknown.
[eva:alarm] tests/value/cert_exp35_c.i:24: Warning:
function printf_va_1: precondition valid_read_string(param0) got status unknown.
+[eva:alarm] tests/value/cert_exp35_c.i:24: Warning:
+ function printf_va_1: precondition valid_read_string(format) got status unknown.
[eva] Done for function printf_va_1
[eva] Recording results for main
[eva] done for function main