(* * This file is part of Coccinelle, licensed under the terms of the GPL v2. * See copyright.txt in the Coccinelle source code for more information. * The Coccinelle source code can be obtained at http://coccinelle.lip6.fr *) module MV = Meta_variable module RuleMap = Map.Make (String) (* ------------------------------------------------------------------------- *) (* Encapsulates all local input for the rule to be generated: * - Description of the script. * - Limitations of the script. * - Keywords for the script. * - Confidence level of the script (Low, Moderate, High). * - Additional comments for the script. * - Coccinelle options with which to call the script. * - Authors of the script (copyright). * Not yet globally configurable; see spgen_config.ml. * - Error messages for org and report mode for each rule. *) (* ------------------------------------------------------------------------- *) (* HELPERS FOR USER INPUT *) let opt s = if s = "" then None else Some s let rev_opt p = function Some s -> p ^ s ^ "\n" | None -> "" (* Count number of format variables, effectively number of unescaped %'s. *) let count_format_vars s = (* ignore escaped percent signs, which in python is %%. *) let s = Str.global_replace (Str.regexp_string "%%") "" s in let rec count_pct acc i s = if i < 0 then acc else if s.[i] = '%' then count_pct (acc+1) (i-1) s else count_pct acc (i-1) s in count_pct 0 ((String.length s)-1) s (* fails if the number of metavariables != the number of % in format str *) let check_format_string (msg, mvs) = let pcts = count_format_vars msg in let mvcount = List.length mvs in if pcts <> mvcount then failwith ("Config error: ill-formed format string.\n" ^ "Number of format variables in the message \"" ^ msg ^ "\": " ^ (string_of_int pcts) ^ "\n" ^ "Number of declared format variables: " ^ (string_of_int mvcount)) (* reconstructs a format string from the message and metavars (as strings) *) let make_format_string msg = let msg = "\"" ^ msg ^ "\"" in function | [] -> msg | x -> let x = List.map MV.tostring_mv x in msg ^ " % " ^ "(" ^ (String.concat "," x) ^ ")" (* turn user-specified metavariable strings into metavariables. * important that they are created with no rulename if within the same rule, * since this is used to generate the right inheritance later on. * They are initialised with type = "" since we don't need it. *) let make_metavars = let mv a = let split_name = Str.bounded_split (Str.regexp "\\.") a 2 in match split_name with | [meta_name] -> MV.make ~typ:"" meta_name | [inherit_rule; meta_name] -> MV.make ~typ:"" ~inherit_rule meta_name | _ -> failwith "bounded split" in List.map mv (* ------------------------------------------------------------------------- *) (* CONFIDENCE TYPE *) (* confidence in the accuracy of the script *) module Confidence = struct type t = Low | Moderate | High exception Not_confidence of string let to_string = function Low -> "Low" | Moderate -> "Moderate" | High -> "High" let from_string s = match Stdcompat.String.lowercase_ascii s with | "low" | "l" -> Low | "moderate" | "m" -> Moderate | "high" | "h" -> High | s -> raise (Not_confidence s) end (* ------------------------------------------------------------------------- *) (* USER RULE TYPE *) (* user-specified data to put in spgenerated script. * type is (rulename, (org message, org metavars), (rep message, rep metavars)) * rulename can be original rulename or a new user-specified one. *) module Rule = struct type t = string * (string * MV.t list) * (string * MV.t list) (* constructor. If rulename is nameless ie. "rule starting on line ...", * generate a new one. *) let make ~rule_name ~org ~report = let ((om,ov),(rm,rv)) = (org, report) in let _ = assert (rule_name <> "" && not(om = "" && rm = "")) in let rule_name = if String.contains rule_name ' ' then Globals.generate_rule rule_name else rule_name in let ov, rv = make_metavars ov, make_metavars rv in (rule_name, (om,ov), (rm,rv)) let get_name (n,_,_) = n let get_org (_,o,_) = o let get_report (_,_,r) = r end (* ------------------------------------------------------------------------- *) (* USER INPUT TYPE *) (* user_input type that covers all the data specified by the user * rules are a map, mapping original rulename to * (new rulename, (org message, org metavars), (rep message, rep metavars) *) type t = { description : string; limitations : string list; keywords : string option; confidence : Confidence.t; comments : string option; options : string option; authors : string list; url : string option; rules : Rule.t RuleMap.t; } (* CONSTRUCTOR, description and confidence levels are required. *) let make ~description ~confidence = if description = "" then failwith "Error: Description is required." else { description; limitations = []; keywords = None; confidence; comments = None; options = None; authors = []; url = None; rules = RuleMap.empty } (* SETTERS *) let add_limit limit t = { t with limitations = limit :: t.limitations } let set_limits limits t = { t with limitations = limits } let set_keys keys t = { t with keywords = opt keys } let set_conf conf t = { t with confidence = conf } let set_comments cmnt t = { t with comments = opt cmnt } let set_options optn t = { t with options = opt optn } let set_url url t = { t with url = opt url } let add_author auth t = { t with authors = auth :: t.authors } let set_authors auths t = { t with authors = auths } (* check that rulename is valid + is not already added. Returns unit. *) let check_name nm t = let already key value = let new_name = Rule.get_name value in (key = new_name && key = nm) || (* nm is same as already added rule *) (new_name = nm) in (* nm is same as other rule with new nm *) if RuleMap.exists already t.rules then failwith ("Error: already another rule named \"" ^ nm ^"\"!") else Globals.check_rule ~strict:true nm (* add rule to rulemap in t. * for nameless rules: check legality of user-declared name. *) let add_rule ~rule_name rule t = let newnm = Rule.get_name rule in let _ = if rule_name <> newnm then check_name newnm t in { t with rules = RuleMap.add rule_name rule t.rules } (* GETTERS *) (* format the preface information and turn it into one big string *) let get_preface ~year { description=d; limitations=l; keywords=k; confidence=c; comments=m; options=o; authors=a; url=u; _ } = let author_format = let year_string = string_of_int year in Globals.pre_split ~prefix:("// Copyright: (C) "^year_string^" ") in let desc = Globals.pre_split ~prefix:"/// " d in let limits = String.concat "\n" (List.map (Globals.pre_split ~prefix:"//# ") l) in let keys = Globals.pre_split_opt ~prefix:"// Keywords: " k in let confidence = "// Confidence: " ^ (Confidence.to_string c) in let comments = Globals.pre_split_opt ~prefix:"// Comments: " m in let options = Globals.pre_split_opt ~prefix:"// Options: " o in let authors = String.concat "\n" (List.map author_format a) in let url = Globals.pre_split_opt ~prefix:"// URL: " u in let preface = [desc; limits; "///"; confidence; authors; url; comments; options; keys] in String.concat "\n" (List.filter ((<>) "") preface) (* get the user-input rulename and org and report messages for rule_name. * if the original rule could not be found in the userinput, use default msg *) let get_rule ~rule_name {rules = r; _} = try RuleMap.find rule_name r with Not_found -> let rulenm = Globals.generate_rule rule_name in let default = Globals.get_default_message() in (rulenm, (default, []), (default, [])) (* ------------------------------------------------------------------------- *) (* UNPARSE USER INPUT INTO CONFIG *) (* turns a rule into the config script that generated it *) let unparse_rule rnm (newnm,(orgmsg,orgmvs),(repmsg,repmvs)) = let orgmsg = make_format_string orgmsg orgmvs in let repmsg = make_format_string repmsg repmvs in let rnm = if rnm <> newnm then let l = Globals.extract_line rnm in (string_of_int l) ^ ":" ^ newnm else rnm in rnm ^ " =\n" ^ " org:" ^ orgmsg ^ "\n report:" ^ repmsg ^ "\n" (* turn a user input collection into its corresponding config script *) let unparse { description; limitations; keywords; confidence; comments; options; rules; authors; url } = let a = "// Generated config\n" in let b = "description = " ^ description ^ "\n" in let c = if limitations = [] then "" else "limitations = " ^ (String.concat "|" limitations) ^ "\n" in let d = rev_opt "keywords = " keywords in let e = "confidence = " ^ (Confidence.to_string confidence) ^ "\n" in let f = rev_opt "comments = " comments in let g = rev_opt "options = " options in let h = if authors = [] then "" else "authors = " ^ (String.concat "|" authors) ^ "\n" in let i = rev_opt "url = " url in let j = RuleMap.fold (fun rnm msg acc -> (unparse_rule rnm msg) :: acc) rules [] in let preface = String.concat "" [a;b;c;d;e;f;g;h;i] in let rules = String.concat "" j in preface ^ rules