ppx_sexp_conv-113.33.03/0000775002755601004200000000000012710357125014071 5ustar jdiminotechppx_sexp_conv-113.33.03/INSTALL.txt0000644002755601004200000000171312710357125015740 0ustar jdiminotech(* OASIS_START *) (* DO NOT EDIT (digest: af8ecbe9d153e2d3db91dbc4e87af9ff) *) This is the INSTALL file for the ppx_sexp_conv distribution. This package uses OASIS to generate its build system. See section OASIS for full information. Dependencies ============ In order to compile this package, you will need: * ocaml (>= 4.02.3) * findlib (>= 1.3.2) * ppx_core * ppx_tools for library ppx_sexp_conv_expander * ppx_type_conv for library ppx_sexp_conv Installing ========== 1. Uncompress the source archive and go to the root of the package 2. Run 'ocaml setup.ml -configure' 3. Run 'ocaml setup.ml -build' 4. Run 'ocaml setup.ml -install' Uninstalling ============ 1. Go to the root of the package 2. Run 'ocaml setup.ml -uninstall' OASIS ===== OASIS is a program that generates a setup.ml file using a simple '_oasis' configuration file. The generated setup only depends on the standard OCaml installation: no additional library is required. (* OASIS_STOP *) ppx_sexp_conv-113.33.03/myocamlbuild.ml0000644002755601004200000004237412710357125017114 0ustar jdiminotech(* OASIS_START *) (* DO NOT EDIT (digest: acb6a683f6e1e5e48dc46789910c996c) *) module OASISGettext = struct (* # 22 "src/oasis/OASISGettext.ml" *) let ns_ str = str let s_ str = str let f_ (str: ('a, 'b, 'c, 'd) format4) = str let fn_ fmt1 fmt2 n = if n = 1 then fmt1^^"" else fmt2^^"" let init = [] end module OASISExpr = struct (* # 22 "src/oasis/OASISExpr.ml" *) open OASISGettext type test = string type flag = string type t = | EBool of bool | ENot of t | EAnd of t * t | EOr of t * t | EFlag of flag | ETest of test * string type 'a choices = (t * 'a) list let eval var_get t = let rec eval' = function | EBool b -> b | ENot e -> not (eval' e) | EAnd (e1, e2) -> (eval' e1) && (eval' e2) | EOr (e1, e2) -> (eval' e1) || (eval' e2) | EFlag nm -> let v = var_get nm in assert(v = "true" || v = "false"); (v = "true") | ETest (nm, vl) -> let v = var_get nm in (v = vl) in eval' t let choose ?printer ?name var_get lst = let rec choose_aux = function | (cond, vl) :: tl -> if eval var_get cond then vl else choose_aux tl | [] -> let str_lst = if lst = [] then s_ "" else String.concat (s_ ", ") (List.map (fun (cond, vl) -> match printer with | Some p -> p vl | None -> s_ "") lst) in match name with | Some nm -> failwith (Printf.sprintf (f_ "No result for the choice list '%s': %s") nm str_lst) | None -> failwith (Printf.sprintf (f_ "No result for a choice list: %s") str_lst) in choose_aux (List.rev lst) end # 132 "myocamlbuild.ml" module BaseEnvLight = struct (* # 22 "src/base/BaseEnvLight.ml" *) module MapString = Map.Make(String) type t = string MapString.t let default_filename = Filename.concat (Sys.getcwd ()) "setup.data" let load ?(allow_empty=false) ?(filename=default_filename) () = if Sys.file_exists filename then begin let chn = open_in_bin filename in let st = Stream.of_channel chn in let line = ref 1 in let st_line = Stream.from (fun _ -> try match Stream.next st with | '\n' -> incr line; Some '\n' | c -> Some c with Stream.Failure -> None) in let lexer = Genlex.make_lexer ["="] st_line in let rec read_file mp = match Stream.npeek 3 lexer with | [Genlex.Ident nm; Genlex.Kwd "="; Genlex.String value] -> Stream.junk lexer; Stream.junk lexer; Stream.junk lexer; read_file (MapString.add nm value mp) | [] -> mp | _ -> failwith (Printf.sprintf "Malformed data file '%s' line %d" filename !line) in let mp = read_file MapString.empty in close_in chn; mp end else if allow_empty then begin MapString.empty end else begin failwith (Printf.sprintf "Unable to load environment, the file '%s' doesn't exist." filename) end let rec var_expand str env = let buff = Buffer.create ((String.length str) * 2) in Buffer.add_substitute buff (fun var -> try var_expand (MapString.find var env) env with Not_found -> failwith (Printf.sprintf "No variable %s defined when trying to expand %S." var str)) str; Buffer.contents buff let var_get name env = var_expand (MapString.find name env) env let var_choose lst env = OASISExpr.choose (fun nm -> var_get nm env) lst end # 237 "myocamlbuild.ml" module MyOCamlbuildFindlib = struct (* # 22 "src/plugins/ocamlbuild/MyOCamlbuildFindlib.ml" *) (** OCamlbuild extension, copied from * http://brion.inria.fr/gallium/index.php/Using_ocamlfind_with_ocamlbuild * by N. Pouillard and others * * Updated on 2009/02/28 * * Modified by Sylvain Le Gall *) open Ocamlbuild_plugin type conf = { no_automatic_syntax: bool; } (* these functions are not really officially exported *) let run_and_read = Ocamlbuild_pack.My_unix.run_and_read let blank_sep_strings = Ocamlbuild_pack.Lexers.blank_sep_strings let exec_from_conf exec = let exec = let env_filename = Pathname.basename BaseEnvLight.default_filename in let env = BaseEnvLight.load ~filename:env_filename ~allow_empty:true () in try BaseEnvLight.var_get exec env with Not_found -> Printf.eprintf "W: Cannot get variable %s\n" exec; exec in let fix_win32 str = if Sys.os_type = "Win32" then begin let buff = Buffer.create (String.length str) in (* Adapt for windowsi, ocamlbuild + win32 has a hard time to handle '\\'. *) String.iter (fun c -> Buffer.add_char buff (if c = '\\' then '/' else c)) str; Buffer.contents buff end else begin str end in fix_win32 exec let split s ch = let buf = Buffer.create 13 in let x = ref [] in let flush () = x := (Buffer.contents buf) :: !x; Buffer.clear buf in String.iter (fun c -> if c = ch then flush () else Buffer.add_char buf c) s; flush (); List.rev !x let split_nl s = split s '\n' let before_space s = try String.before s (String.index s ' ') with Not_found -> s (* ocamlfind command *) let ocamlfind x = S[Sh (exec_from_conf "ocamlfind"); x] (* This lists all supported packages. *) let find_packages () = List.map before_space (split_nl & run_and_read (exec_from_conf "ocamlfind" ^ " list")) (* Mock to list available syntaxes. *) let find_syntaxes () = ["camlp4o"; "camlp4r"] let well_known_syntax = [ "camlp4.quotations.o"; "camlp4.quotations.r"; "camlp4.exceptiontracer"; "camlp4.extend"; "camlp4.foldgenerator"; "camlp4.listcomprehension"; "camlp4.locationstripper"; "camlp4.macro"; "camlp4.mapgenerator"; "camlp4.metagenerator"; "camlp4.profiler"; "camlp4.tracer" ] let dispatch conf = function | After_options -> (* By using Before_options one let command line options have an higher * priority on the contrary using After_options will guarantee to have * the higher priority override default commands by ocamlfind ones *) Options.ocamlc := ocamlfind & A"ocamlc"; Options.ocamlopt := ocamlfind & A"ocamlopt"; Options.ocamldep := ocamlfind & A"ocamldep"; Options.ocamldoc := ocamlfind & A"ocamldoc"; Options.ocamlmktop := ocamlfind & A"ocamlmktop"; Options.ocamlmklib := ocamlfind & A"ocamlmklib" | After_rules -> (* When one link an OCaml library/binary/package, one should use * -linkpkg *) flag ["ocaml"; "link"; "program"] & A"-linkpkg"; if not (conf.no_automatic_syntax) then begin (* For each ocamlfind package one inject the -package option when * compiling, computing dependencies, generating documentation and * linking. *) List.iter begin fun pkg -> let base_args = [A"-package"; A pkg] in (* TODO: consider how to really choose camlp4o or camlp4r. *) let syn_args = [A"-syntax"; A "camlp4o"] in let (args, pargs) = (* Heuristic to identify syntax extensions: whether they end in ".syntax"; some might not. *) if Filename.check_suffix pkg "syntax" || List.mem pkg well_known_syntax then (syn_args @ base_args, syn_args) else (base_args, []) in flag ["ocaml"; "compile"; "pkg_"^pkg] & S args; flag ["ocaml"; "ocamldep"; "pkg_"^pkg] & S args; flag ["ocaml"; "doc"; "pkg_"^pkg] & S args; flag ["ocaml"; "link"; "pkg_"^pkg] & S base_args; flag ["ocaml"; "infer_interface"; "pkg_"^pkg] & S args; (* TODO: Check if this is allowed for OCaml < 3.12.1 *) flag ["ocaml"; "compile"; "package("^pkg^")"] & S pargs; flag ["ocaml"; "ocamldep"; "package("^pkg^")"] & S pargs; flag ["ocaml"; "doc"; "package("^pkg^")"] & S pargs; flag ["ocaml"; "infer_interface"; "package("^pkg^")"] & S pargs; end (find_packages ()); end; (* Like -package but for extensions syntax. Morover -syntax is useless * when linking. *) List.iter begin fun syntax -> flag ["ocaml"; "compile"; "syntax_"^syntax] & S[A"-syntax"; A syntax]; flag ["ocaml"; "ocamldep"; "syntax_"^syntax] & S[A"-syntax"; A syntax]; flag ["ocaml"; "doc"; "syntax_"^syntax] & S[A"-syntax"; A syntax]; flag ["ocaml"; "infer_interface"; "syntax_"^syntax] & S[A"-syntax"; A syntax]; end (find_syntaxes ()); (* The default "thread" tag is not compatible with ocamlfind. * Indeed, the default rules add the "threads.cma" or "threads.cmxa" * options when using this tag. When using the "-linkpkg" option with * ocamlfind, this module will then be added twice on the command line. * * To solve this, one approach is to add the "-thread" option when using * the "threads" package using the previous plugin. *) flag ["ocaml"; "pkg_threads"; "compile"] (S[A "-thread"]); flag ["ocaml"; "pkg_threads"; "doc"] (S[A "-I"; A "+threads"]); flag ["ocaml"; "pkg_threads"; "link"] (S[A "-thread"]); flag ["ocaml"; "pkg_threads"; "infer_interface"] (S[A "-thread"]); flag ["ocaml"; "package(threads)"; "compile"] (S[A "-thread"]); flag ["ocaml"; "package(threads)"; "doc"] (S[A "-I"; A "+threads"]); flag ["ocaml"; "package(threads)"; "link"] (S[A "-thread"]); flag ["ocaml"; "package(threads)"; "infer_interface"] (S[A "-thread"]); | _ -> () end module MyOCamlbuildBase = struct (* # 22 "src/plugins/ocamlbuild/MyOCamlbuildBase.ml" *) (** Base functions for writing myocamlbuild.ml @author Sylvain Le Gall *) open Ocamlbuild_plugin module OC = Ocamlbuild_pack.Ocaml_compiler type dir = string type file = string type name = string type tag = string (* # 62 "src/plugins/ocamlbuild/MyOCamlbuildBase.ml" *) type t = { lib_ocaml: (name * dir list * string list) list; lib_c: (name * dir * file list) list; flags: (tag list * (spec OASISExpr.choices)) list; (* Replace the 'dir: include' from _tags by a precise interdepends in * directory. *) includes: (dir * dir list) list; } let env_filename = Pathname.basename BaseEnvLight.default_filename let dispatch_combine lst = fun e -> List.iter (fun dispatch -> dispatch e) lst let tag_libstubs nm = "use_lib"^nm^"_stubs" let nm_libstubs nm = nm^"_stubs" let dispatch t e = let env = BaseEnvLight.load ~filename:env_filename ~allow_empty:true () in match e with | Before_options -> let no_trailing_dot s = if String.length s >= 1 && s.[0] = '.' then String.sub s 1 ((String.length s) - 1) else s in List.iter (fun (opt, var) -> try opt := no_trailing_dot (BaseEnvLight.var_get var env) with Not_found -> Printf.eprintf "W: Cannot get variable %s\n" var) [ Options.ext_obj, "ext_obj"; Options.ext_lib, "ext_lib"; Options.ext_dll, "ext_dll"; ] | After_rules -> (* Declare OCaml libraries *) List.iter (function | nm, [], intf_modules -> ocaml_lib nm; let cmis = List.map (fun m -> (String.uncapitalize m) ^ ".cmi") intf_modules in dep ["ocaml"; "link"; "library"; "file:"^nm^".cma"] cmis | nm, dir :: tl, intf_modules -> ocaml_lib ~dir:dir (dir^"/"^nm); List.iter (fun dir -> List.iter (fun str -> flag ["ocaml"; "use_"^nm; str] (S[A"-I"; P dir])) ["compile"; "infer_interface"; "doc"]) tl; let cmis = List.map (fun m -> dir^"/"^(String.uncapitalize m)^".cmi") intf_modules in dep ["ocaml"; "link"; "library"; "file:"^dir^"/"^nm^".cma"] cmis) t.lib_ocaml; (* Declare directories dependencies, replace "include" in _tags. *) List.iter (fun (dir, include_dirs) -> Pathname.define_context dir include_dirs) t.includes; (* Declare C libraries *) List.iter (fun (lib, dir, headers) -> (* Handle C part of library *) flag ["link"; "library"; "ocaml"; "byte"; tag_libstubs lib] (S[A"-dllib"; A("-l"^(nm_libstubs lib)); A"-cclib"; A("-l"^(nm_libstubs lib))]); flag ["link"; "library"; "ocaml"; "native"; tag_libstubs lib] (S[A"-cclib"; A("-l"^(nm_libstubs lib))]); flag ["link"; "program"; "ocaml"; "byte"; tag_libstubs lib] (S[A"-dllib"; A("dll"^(nm_libstubs lib))]); (* When ocaml link something that use the C library, then one need that file to be up to date. This holds both for programs and for libraries. *) dep ["link"; "ocaml"; tag_libstubs lib] [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)]; dep ["compile"; "ocaml"; tag_libstubs lib] [dir/"lib"^(nm_libstubs lib)^"."^(!Options.ext_lib)]; (* TODO: be more specific about what depends on headers *) (* Depends on .h files *) dep ["compile"; "c"] headers; (* Setup search path for lib *) flag ["link"; "ocaml"; "use_"^lib] (S[A"-I"; P(dir)]); ) t.lib_c; (* Add flags *) List.iter (fun (tags, cond_specs) -> let spec = BaseEnvLight.var_choose cond_specs env in let rec eval_specs = function | S lst -> S (List.map eval_specs lst) | A str -> A (BaseEnvLight.var_expand str env) | spec -> spec in flag tags & (eval_specs spec)) t.flags | _ -> () let dispatch_default conf t = dispatch_combine [ dispatch t; MyOCamlbuildFindlib.dispatch conf; ] end # 606 "myocamlbuild.ml" open Ocamlbuild_plugin;; let package_default = { MyOCamlbuildBase.lib_ocaml = [ ("ppx_sexp_conv_expander", ["expander"], []); ("ppx_sexp_conv", ["src"], []) ]; lib_c = []; flags = []; includes = [("src", ["expander"])] } ;; let conf = {MyOCamlbuildFindlib.no_automatic_syntax = false} let dispatch_default = MyOCamlbuildBase.dispatch_default conf package_default;; # 626 "myocamlbuild.ml" (* OASIS_STOP *) # 3 "myocamlbuild.ml" module JS = Jane_street_ocamlbuild_goodies let dev_mode = false let () = Ocamlbuild_plugin.dispatch (fun hook -> JS.alt_cmxs_of_cmxa_rule hook; JS.pass_predicates_to_ocamldep hook; if dev_mode && not Sys.win32 then JS.track_external_deps hook; dispatch_default hook) ppx_sexp_conv-113.33.03/install.ml0000664002755601004200000000034612710355760016077 0ustar jdiminotech#use "topfind";; #require "js-build-tools.oasis2opam_install";; open Oasis2opam_install;; generate ~package:"ppx_sexp_conv" [ oasis_lib "ppx_sexp_conv" ; oasis_lib "ppx_sexp_conv_expander" ; file "META" ~section:"lib" ] ppx_sexp_conv-113.33.03/src/0000775002755601004200000000000012710357125014660 5ustar jdiminotechppx_sexp_conv-113.33.03/src/ppx_sexp_conv.mllib0000644002755601004200000000014212710357125020567 0ustar jdiminotech# OASIS_START # DO NOT EDIT (digest: 9c8652cd9b8142ab53f8f6a4d36145d2) Ppx_sexp_conv # OASIS_STOP ppx_sexp_conv-113.33.03/src/ppx_sexp_conv.mli0000664002755601004200000000000012710355760020247 0ustar jdiminotechppx_sexp_conv-113.33.03/src/ppx_sexp_conv.ml0000664002755601004200000000411112710355760020105 0ustar jdiminotech(* sexp_conv: Preprocessing Module for Automated S-expression Conversions *) open! StdLabels open Ppx_core.Std module Type_conv = Ppx_type_conv.Std.Type_conv module Attrs = Ppx_sexp_conv_expander.Attrs module Sexp_of = struct module E = Ppx_sexp_conv_expander.Sexp_of let str_type_decl = Type_conv.Generator.make_noarg E.str_type_decl ~attributes:[ Attribute.T Attrs.default ; Attribute.T Attrs.drop_default ; Attribute.T Attrs.drop_if ] ;; let str_exception = Type_conv.Generator.make_noarg E.str_exception ;; let sig_type_decl = Type_conv.Generator.make_noarg E.sig_type_decl ;; let sig_exception = Type_conv.Generator.make_noarg E.sig_exception ;; let extension ~loc:_ ~path:_ ctyp = E.core_type ctyp let deriver = Type_conv.add "sexp_of" ~str_type_decl ~str_exception ~sig_type_decl ~sig_exception ~extension ;; end module Of_sexp = struct module E = Ppx_sexp_conv_expander.Of_sexp let str_type_decl = Type_conv.Generator.make_noarg (E.str_type_decl ~poly:false) ~attributes:[ Attribute.T Attrs.default ] ;; let sig_type_decl = Type_conv.Generator.make_noarg (E.sig_type_decl ~poly:false) ;; let extension ~loc:_ ~path ctyp = E.core_type ~path ctyp let deriver = Type_conv.add "of_sexp" ~str_type_decl ~sig_type_decl ~extension ;; end module Of_sexp_poly = struct module E = Ppx_sexp_conv_expander.Of_sexp let str_type_decl = Type_conv.Generator.make_noarg (E.str_type_decl ~poly:true) ~attributes:[ Attribute.T Attrs.default ] ;; let sig_type_decl = Type_conv.Generator.make_noarg (E.sig_type_decl ~poly:true) ;; let deriver = Type_conv.add "of_sexp_poly" ~sig_type_decl ~str_type_decl ;; end let () = Type_conv.add_alias "sexp" [Sexp_of.deriver; Of_sexp.deriver] ~str_exception:[Sexp_of.deriver] ~sig_exception:[Sexp_of.deriver] |> Type_conv.ignore; Type_conv.add_alias "sexp_poly" [Sexp_of.deriver; Of_sexp_poly.deriver] |> Type_conv.ignore; ;; ppx_sexp_conv-113.33.03/src/ppx_sexp_conv.mldylib0000644002755601004200000000014212710357125021124 0ustar jdiminotech# OASIS_START # DO NOT EDIT (digest: 9c8652cd9b8142ab53f8f6a4d36145d2) Ppx_sexp_conv # OASIS_STOP ppx_sexp_conv-113.33.03/configure0000755002755601004200000000055312710357125016001 0ustar jdiminotech#!/bin/sh # OASIS_START # DO NOT EDIT (digest: dc86c2ad450f91ca10c931b6045d0499) set -e FST=true for i in "$@"; do if $FST; then set -- FST=false fi case $i in --*=*) ARG=${i%%=*} VAL=${i##*=} set -- "$@" "$ARG" "$VAL" ;; *) set -- "$@" "$i" ;; esac done ocaml setup.ml -configure "$@" # OASIS_STOP ppx_sexp_conv-113.33.03/expander/0000775002755601004200000000000012710357125015677 5ustar jdiminotechppx_sexp_conv-113.33.03/expander/ppx_sexp_conv_expander.ml0000664002755601004200000015340512710355760023025 0ustar jdiminotechopen StdLabels open MoreLabels open Ppx_core.Std open Asttypes open Parsetree open Ast_builder.Default [@@@metaloc loc] module StringMap = Map.Make(String) let ( --> ) lhs rhs = case ~guard:None ~lhs ~rhs module Attrs = struct let default = Attribute.declare "sexp.default" Attribute.Context.label_declaration Ast_pattern.(pstr (pstr_eval __ nil ^:: nil)) (fun x -> x) let drop_default = Attribute.declare "sexp.sexp_drop_default" Attribute.Context.label_declaration Ast_pattern.(pstr nil) () let drop_if = Attribute.declare "sexp.sexp_drop_if" Attribute.Context.label_declaration Ast_pattern.(pstr (pstr_eval __ nil ^:: nil)) (fun x -> x) end module Fun_or_match = struct type t = | Fun of expression | Match of case list let expr ~loc t = match t with | Fun f -> f | Match cases -> pexp_function ~loc cases let unroll ~loc e t = match t with | Fun f -> eapply ~loc f [e] | Match cases -> pexp_match ~loc e cases let map_tmp_vars ~loc ts = let vars = List.mapi ts ~f:(fun i _ -> "v" ^ string_of_int i) in let bindings = List.map2 vars ts ~f:(fun var t -> let expr = unroll ~loc (evar ~loc var) t in value_binding ~loc ~pat:(pvar ~loc var) ~expr) in (bindings, List.map vars ~f:(pvar ~loc), List.map vars ~f:(evar ~loc)) end (* A renaming is a mapping from type variable name to type variable name. In definitions such as: type 'a t = | A : -> 'b t | B of 'a we generate a function that takes an sexp_of parameter named after 'a, but 'a is not in scope in when handling the constructor A (because A is a gadt constructor). Instead the type variables in scope are the ones defined in the return type of A, namely 'b. There could be less or more type variable in cases such as: type _ less = Less : int less type _ more = More : ('a * 'a) more If for instance, is ['b * 'c], when we find 'b, we will look for ['b] in the renaming and find ['a] (only in that gadt branch, it could be something else in other branches), at which point we can call the previously bound sexp_of parameter named after 'a. If we can't find a resulting name, like when looking up ['c] in the renaming, then we assume the variable is existentially quantified and treat it as [_] (which is ok, assuming there are no constraints). *) module Renaming : sig type t val identity : t type binding_kind = | Universally_bound of string | Existentially_bound val binding_kind : t -> string -> binding_kind val of_gadt : string list -> constructor_declaration -> t end = struct type ('a, 'b) result = Ok of 'a | Error of 'b type t = (string, Location.error) result StringMap.t option let identity = None type binding_kind = | Universally_bound of string | Existentially_bound let binding_kind t var = match t with | None -> Universally_bound var | Some map -> match StringMap.find var map with | exception Not_found -> Existentially_bound | Ok value -> Universally_bound value | Error error -> raise (Location.Error error) (* Return a map translating type variables appearing in the return type of a GADT constructor to their name in the type parameter list. For instance: {[ type ('a, 'b) t = X : 'x * 'y -> ('x, 'y) t ]} will produce: {[ "x" -> Ok "a" "y" -> Ok "b" ]} If a variable appears twice in the return type it will map to [Error _]. If a variable cannot be mapped to a parameter of the type declaration, it will map to [Error] (for instance [A : 'a -> 'a list t]). It returns None on user error, to let the typer give the error message *) let of_gadt = (* Add all type variables of a type to a map. *) let add_typevars = object inherit [ (string, Location.error) result StringMap.t ] Ast_traverse.fold as super method! core_type ty map = match ty.ptyp_desc with | Ptyp_var var -> let error = Location.error ~loc:ty.ptyp_loc "ppx_sexp_conv: variable is not a parameter of the type constructor" in StringMap.add map ~key:var ~data:(Error error) | _ -> super#core_type ty map end in let aux map tp_name tp_in_return_type = match tp_in_return_type.ptyp_desc with | Ptyp_var var -> let data = if StringMap.mem var map then let loc = tp_in_return_type.ptyp_loc in Error (Location.error ~loc "ppx_sexp_conv: duplicate variable") else Ok tp_name in StringMap.add map ~key:var ~data | _ -> add_typevars#core_type tp_in_return_type map in fun tps cd -> match cd.pcd_res with | None -> None | Some ty -> match ty.ptyp_desc with | Ptyp_constr (_, params) -> if List.length params <> List.length tps then None else Some (List.fold_left2 tps params ~init:StringMap.empty ~f:aux) | _ -> None end (* Utility functions *) let replace_variables_by_underscores = let map = object inherit Ast_traverse.map as super method! core_type_desc = function | Ptyp_var _ -> Ptyp_any | t -> super#core_type_desc t end in map#core_type let name_type_params_in_td (td : type_declaration) : type_declaration = let name_param (tp, variance) = let ptyp_desc = match tp.ptyp_desc with | Ptyp_any -> Ptyp_var ("v" ^ gen_symbol ()) | Ptyp_var _ as v -> v | _ -> Location.raise_errorf ~loc:tp.ptyp_loc "ppx_sexp_conv: not a type parameter" in ({ tp with ptyp_desc }, variance) in { td with ptype_params = List.map td.ptype_params ~f:name_param } let make_type_rigid = let map = object inherit Ast_traverse.map as super method! core_type ty = let ptyp_desc = match ty.ptyp_desc with | Ptyp_var s -> Ptyp_constr (Located.lident ~loc:ty.ptyp_loc s, []) | desc -> super#core_type_desc desc in { ty with ptyp_desc } end in map#core_type (* Generates the quantified type [ ! 'a .. 'z . (make_mono_type t ('a .. 'z)) ] or [type a .. z. make_mono_type t (a .. z)] when [use_rigid_variables] is true. Annotation are needed for non regular recursive datatypes and gadt when the return type of constructors are constrained. Unfortunately, putting rigid variables everywhere does not work because of certains types with constraints. We thus only use rigid variables for sum types, which includes all GADTs. *) let tvars_of_core_type : (core_type -> string list) = let tvars = object inherit [string list] Ast_traverse.fold as super method! core_type x acc = match x.ptyp_desc with | Ptyp_var x -> if List.mem x ~set:acc then acc else x :: acc | _ -> super#core_type x acc end in fun typ -> List.rev (tvars#core_type typ []) let constrained_function_binding = fun (* placing a suitably polymorphic or rigid type constraint on the pattern or body *) (loc:Location.t) (td:type_declaration) (typ:core_type) ~(tps:string list) ~(func_name:string) (body:expression) -> let vars = tvars_of_core_type typ in let has_vars = match vars with [] -> false | _::_ -> true in let pat = let pat = pvar ~loc func_name in if not has_vars then pat else ppat_constraint ~loc pat (ptyp_poly ~loc vars typ) in let body = let use_rigid_variables = match td.ptype_kind with | Ptype_variant _ -> true | _ -> false in if use_rigid_variables then List.fold_right tps ~f:(pexp_newtype ~loc) ~init:(pexp_constraint ~loc body (make_type_rigid typ)) else if has_vars then body else pexp_constraint ~loc body typ in value_binding ~loc ~pat ~expr:body let sexp_type_is_recursive = types_are_recursive ~short_circuit:(fun typ -> match typ with | [%type: [%t? _] sexp_opaque ] -> Some false | _ -> None) let really_recursive rec_flag tds = match rec_flag with | Recursive -> if sexp_type_is_recursive tds then Recursive else Nonrecursive | Nonrecursive -> Nonrecursive let combinator_type_of_td ~f td = let td = name_type_params_in_td td in combinator_type_of_type_declaration td ~f (* Generates the signature for type conversion to S-expressions *) module Sig_generate_sexp_of = struct let mk_type td = combinator_type_of_td td ~f:(fun ~loc t -> [%type: [%t t] -> Sexplib.Sexp.t]) let mk_sig ~loc:_ ~path:_ (_rf, tds) = List.map tds ~f:(fun td -> let loc = td.ptype_loc in psig_value ~loc (value_description ~loc ~name:(Located.map ((^) "sexp_of_") td.ptype_name) ~type_:(mk_type td) ~prim:[])) let mk_sig_exn ~loc:_ ~path:_ _te = [] end let is_polymorphic_variant = let rec check = function | { ptyp_desc = Ptyp_variant _; _ } -> `Definitely | { ptyp_desc = Ptyp_alias (typ,_); _ } -> check typ | { ptyp_desc = Ptyp_constr _; _ } -> `Maybe | _ -> `Surely_not (* Type vars go here even though they could be polymorphic variants, however we don't handle it if they get substituted by a polymorphic variant that is then included. *) in fun td ~sig_ -> match td.ptype_kind with | Ptype_variant _ | Ptype_record _ | Ptype_open -> `Surely_not | Ptype_abstract -> match td.ptype_manifest with | None -> if sig_ then `Maybe else `Surely_not | Some typ -> check typ (* Generates the signature for type conversion from S-expressions *) module Sig_generate_of_sexp = struct let mk_type td = combinator_type_of_td td ~f:(fun ~loc t -> [%type: Sexplib.Sexp.t -> [%t t] ]) let sig_of_td with_poly td = let of_sexp_type = mk_type td in let loc = td.ptype_loc in let of_sexp_item = psig_value ~loc (value_description ~loc ~name:(Located.map (fun s -> s ^ "_of_sexp") td.ptype_name) ~type_:of_sexp_type ~prim:[]) in match with_poly, is_polymorphic_variant td ~sig_:true with | true, `Surely_not -> Location.raise_errorf ~loc "Sig_generate_of_sexp.sig_of_td: sexp_poly annotation \ but type is surely not a polymorphic variant" | false, (`Surely_not | `Maybe) -> [of_sexp_item] | (true | false), `Definitely | true, `Maybe -> [ of_sexp_item ; psig_value ~loc (value_description ~loc ~name:(Located.map (fun s -> "__" ^ s ^ "_of_sexp__") td.ptype_name) ~type_:of_sexp_type ~prim:[]) ] let mk_sig ~poly ~loc:_ ~path:_ (_rf, tds) = List.map tds ~f:(sig_of_td poly) |> List.flatten end module Str_generate_sexp_of = struct (* Handling of record defaults *) type record_field_handler = [ `keep | `drop_default | `drop_if of expression ] let get_record_field_handler ~loc ld : record_field_handler = match Attribute.get Attrs.drop_default ld, Attribute.get Attrs.drop_if ld with | None, None -> `keep | Some (), None -> `drop_default | None, Some e -> `drop_if e | Some (), Some _ -> Location.raise_errorf ~loc "sexp record field handler defined twice" (* Conversion of type paths *) let sexp_of_type_id (id : Longident.t Located.t) = let txt : Longident.t = match id.txt with | Lident s -> Lident ("sexp_of_" ^ s) | Ldot (p, s) -> Ldot (p, "sexp_of_" ^ s) | Lapply _ -> failwith "Ppx_sexp_conv_expander.sexp_of_type_id" in pexp_ident ~loc:id.loc { id with txt } (* Conversion of types *) let rec sexp_of_type (renaming : Renaming.t) typ : Fun_or_match.t = let loc = typ.ptyp_loc in match typ with | [%type: _ ] -> Fun [%expr fun _ -> Sexp.Atom "_" ] | [%type: [%t? _] sexp_opaque ] -> Fun [%expr Sexplib.Conv.sexp_of_opaque ] | { ptyp_desc = Ptyp_tuple tp; _ } -> Match [sexp_of_tuple renaming (loc,tp)] | { ptyp_desc = Ptyp_var parm; _ } -> begin match Renaming.binding_kind renaming parm with | Universally_bound parm -> Fun (evar ~loc ("_of_" ^ parm)) | Existentially_bound -> sexp_of_type renaming [%type: _ ] end | { ptyp_desc = Ptyp_constr (id, args); _ } -> let init = sexp_of_type_id id in Fun (List.fold_left args ~init ~f:(fun exp1 tp2 -> let exp2 = Fun_or_match.expr ~loc (sexp_of_type renaming tp2) in [%expr [%e exp1] [%e exp2]])) | { ptyp_desc = Ptyp_arrow (_,_,_); _ } -> Fun [%expr fun _f -> Sexplib.Conv.sexp_of_fun Pervasives.ignore ] | { ptyp_desc = Ptyp_variant (row_fields, _, _); _ } -> sexp_of_variant renaming (loc,row_fields) | { ptyp_desc = Ptyp_poly (parms, poly_tp); _ } -> sexp_of_poly renaming parms poly_tp | { ptyp_desc = Ptyp_object (_, _); _ } | { ptyp_desc = Ptyp_class (_, _); _ } | { ptyp_desc = Ptyp_alias (_, _); _ } | { ptyp_desc = Ptyp_package _; _ } | { ptyp_desc = Ptyp_extension _; _ } -> Location.raise_errorf ~loc "unknown type" (* Conversion of tuples *) and sexp_of_tuple renaming (loc,tps) = let fps = List.map ~f:(fun tp -> sexp_of_type renaming tp) tps in let bindings, pvars, evars = Fun_or_match.map_tmp_vars ~loc fps in let in_expr = [%expr Sexplib.Sexp.List [%e elist ~loc evars] ] in let expr = pexp_let ~loc Nonrecursive bindings in_expr in ppat_tuple ~loc pvars --> expr (* Conversion of variant types *) and sexp_of_variant renaming ((loc,row_fields):(Location.t * row_field list)) : Fun_or_match.t = let item = function | Rtag (cnstr,_,true,[]) -> ppat_variant ~loc cnstr None --> [%expr Sexplib.Sexp.Atom [%e estring ~loc cnstr]] | Rtag (cnstr,_,_,[ [%type: [%t? tp] sexp_list] ]) -> let cnv_expr = Fun_or_match.expr ~loc (sexp_of_type renaming tp) in ppat_variant ~loc cnstr (Some [%pat? l]) --> [%expr Sexplib.Sexp.List ( Sexplib.Sexp.Atom [%e estring ~loc cnstr] :: Sexplib.Conv.list_map [%e cnv_expr] l ) ] | Rtag (cnstr,_,false,[tp]) -> let cnstr_expr = [%expr Sexplib.Sexp.Atom [%e estring ~loc cnstr] ] in let var, patt = evar ~loc "v0", pvar ~loc "v0" in let cnstr_arg = Fun_or_match.unroll ~loc var (sexp_of_type renaming tp) in let expr = [%expr Sexplib.Sexp.List [%e elist ~loc [cnstr_expr; cnstr_arg]]] in ppat_variant ~loc cnstr (Some patt) --> expr | Rinherit { ptyp_desc = Ptyp_constr (id, []); _ } -> let call = sexp_of_type_id id in ppat_alias ~loc (ppat_type ~loc id) (Location.mkloc "v" loc) --> [%expr [%e call] v] | Rtag (_,_,true,[_]) | Rtag (_,_,_,_::_::_) -> Location.raise_errorf ~loc "unsupported: sexp_of_variant/Rtag/&" | Rinherit ({ ptyp_desc = Ptyp_constr (id, _::_); _ } as typ) -> let call = Fun_or_match.expr ~loc (sexp_of_type renaming typ) in ppat_alias ~loc (ppat_type ~loc id) (Location.mkloc "v" loc) --> [%expr [%e call] v] | Rinherit _ -> Location.raise_errorf ~loc "unsupported: sexp_of_variant/Rinherit/non-id" (* impossible?*) | Rtag (_,_,false,[]) -> assert false in Match (List.map ~f:item row_fields) (* Polymorphic record fields *) and sexp_of_poly renaming parms tp = assert (renaming = Renaming.identity); (* because this is only for record fields. Otherwise, we'd need to update the renaming with the newly bound vars. *) let loc = tp.ptyp_loc in let bindings = let mk_binding parm = value_binding ~loc ~pat:(pvar ~loc ("_of_" ^ parm)) ~expr:[%expr Sexplib.Conv.sexp_of_opaque] in List.map ~f:mk_binding parms in match sexp_of_type renaming tp with | Fun fun_expr -> Fun (pexp_let ~loc Nonrecursive bindings fun_expr) | Match matchings -> Match [ [%pat? arg] --> pexp_let ~loc Nonrecursive bindings (pexp_match ~loc [%expr arg] matchings) ] (* Conversion of sum types *) let branch_sum tvars cds = List.map cds ~f:(fun cd -> let renaming = Renaming.of_gadt tvars cd in let loc = cd.pcd_loc in let cnstr = cd.pcd_name in let lid = Located.map lident cnstr in let str = estring ~loc cnstr.txt in match cd.pcd_args with | [] -> ppat_construct ~loc lid None --> [%expr Sexplib.Sexp.Atom [%e str]] | args -> match args with | [ [%type: [%t? tp] sexp_list ] ] -> let cnv_expr = Fun_or_match.expr ~loc (sexp_of_type renaming tp) in ppat_construct ~loc lid (Some [%pat? l]) --> [%expr Sexplib.Sexp.List (Sexplib.Sexp.Atom [%e str] :: Sexplib.Conv.list_map [%e cnv_expr] l)] | _ -> let sexp_of_args = List.map ~f:(sexp_of_type renaming) args in let cnstr_expr = [%expr Sexplib.Sexp.Atom [%e str] ] in let bindings, patts, vars = Fun_or_match.map_tmp_vars ~loc sexp_of_args in let patt = match patts with | [patt] -> patt | _ -> ppat_tuple ~loc patts in ppat_construct ~loc lid (Some patt) --> pexp_let ~loc Nonrecursive bindings [%expr Sexplib.Sexp.List [%e elist ~loc (cnstr_expr :: vars)]] ) let sexp_of_sum tps cds = Fun_or_match.Match (branch_sum tps cds) (* Conversion of record types *) let mk_rec_patt loc patt name = let p = Location.mkloc (Longident.Lident name) loc , pvar ~loc ("v_" ^ name) in patt @ [p] let sexp_of_record_field patt expr name tp ?sexp_of is_empty_expr = let renaming = Renaming.identity in let loc = tp.ptyp_loc in let patt = mk_rec_patt loc patt name in let cnv_expr = match (sexp_of_type renaming tp) with | Fun exp -> exp | Match matchings -> [%expr fun el -> [%e pexp_match ~loc [%expr el] matchings]] in let cnv_expr = match sexp_of with | None -> cnv_expr | Some sexp_of -> [%expr [%e sexp_of] [%e cnv_expr] ] in let expr = let v_name = [%expr [%e "v_" ^ name] ] in [%expr let bnds = if [%e is_empty_expr loc (evar ~loc v_name)] then bnds else let arg = [%e cnv_expr] [%e evar ~loc v_name] in let bnd = Sexplib.Sexp.List [Sexplib.Sexp.Atom [%e estring ~loc name]; arg] in bnd :: bnds in [%e expr] ] in patt, expr let sexp_of_default_field patt expr name tp ?sexp_of default = sexp_of_record_field patt expr name tp ?sexp_of (fun loc expr -> [%expr Pervasives.(=) [%e default] [%e expr] ]) let sexp_of_record (loc,flds) : Fun_or_match.t = let renaming = Renaming.identity in let list_empty_expr loc lst = [%expr match [%e lst] with | [] -> true | _ -> false ] in let array_empty_expr loc arr = [%expr match [%e arr] with | [||] -> true | _ -> false ] in let coll ((patt : (Longident.t loc * pattern) list), expr) = function | {pld_name = {txt=name; loc}; pld_type = [%type: [%t? tp] sexp_option]; _ } -> let patt = mk_rec_patt loc patt name in let vname = [%expr v ] in let cnv_expr = Fun_or_match.unroll ~loc vname (sexp_of_type renaming tp) in let expr = [%expr let bnds = match [%e evar ~loc ("v_" ^ name)] with | None -> bnds | Some v -> let arg = [%e cnv_expr] in let bnd = Sexplib.Sexp.List [Sexplib.Sexp.Atom [%e estring ~loc name]; arg] in bnd :: bnds in [%e expr] ] in patt, expr | {pld_name = {txt=name; loc}; pld_type = [%type: sexp_bool]; _ } -> let patt = mk_rec_patt loc patt name in let expr = [%expr let bnds = if [%e evar ~loc ("v_" ^ name)] then let bnd = Sexplib.Sexp.List [Sexplib.Sexp.Atom [%e estring ~loc name]] in bnd :: bnds else bnds in [%e expr] ] in patt, expr | {pld_name = {txt=name; loc}; pld_type = [%type: [%t? tp] sexp_list]; _ } -> sexp_of_record_field patt expr name tp ~sexp_of:[%expr sexp_of_list ] list_empty_expr | {pld_name = {txt=name; loc}; pld_type = [%type: [%t? tp] sexp_array]; _ } -> sexp_of_record_field patt expr name tp ~sexp_of:[%expr sexp_of_array ] array_empty_expr | {pld_name = {txt=name; loc}; pld_type = tp; _ } as ld -> begin match get_record_field_handler ~loc ld with | `drop_default -> begin match Attribute.get Attrs.default ld with | None -> Location.raise_errorf ~loc "no default to drop" | Some default -> sexp_of_default_field patt expr name tp default end | `drop_if test -> sexp_of_record_field patt expr name tp (fun loc expr -> [%expr [%e test] [%e expr]]) | `keep -> let patt = mk_rec_patt loc patt name in let vname = evar ~loc ("v_" ^ name) in let cnv_expr = Fun_or_match.unroll ~loc vname (sexp_of_type renaming tp) in let expr = [%expr let arg = [%e cnv_expr] in let bnd = Sexplib.Sexp.List [Sexplib.Sexp.Atom [%e estring ~loc name]; arg] in let bnds = bnd :: bnds in [%e expr] ] in patt, expr end in let init_expr = [%expr Sexplib.Sexp.List bnds ] in let patt, expr = List.fold_left ~f:coll ~init:([], init_expr) flds in Match [ ppat_record ~loc patt Closed --> [%expr let bnds = [] in [%e expr]] ] (* Empty type *) let sexp_of_nil loc = Fun_or_match.Fun [%expr fun _v -> assert false ] (* Generate code from type definitions *) let sexp_of_td td = let td = name_type_params_in_td td in let tps = List.map td.ptype_params ~f:(fun tp -> (get_type_param_name tp).txt) in let {ptype_name = {txt = type_name; loc = _}; ptype_loc = loc; _} = td in let body = let body = match td.ptype_kind with | Ptype_variant cds -> sexp_of_sum tps cds | Ptype_record lds -> sexp_of_record (loc,lds) | Ptype_open -> Location.raise_errorf ~loc "ppx_sexp_conv: open types not supported" | Ptype_abstract -> match td.ptype_manifest with | None -> sexp_of_nil loc | Some { ptyp_desc = Ptyp_variant (row_fields, _, _); _ } -> sexp_of_variant Renaming.identity (loc,row_fields) | Some ty -> sexp_of_type Renaming.identity ty in let is_private_alias = match td.ptype_kind, td.ptype_manifest, td.ptype_private with | Ptype_abstract, Some _, Private -> true | _ -> false in if is_private_alias then (* Replace all type variable by _ to avoid generalization problems *) let ty_src = core_type_of_type_declaration td |> replace_variables_by_underscores in let manifest = match td.ptype_manifest with | Some manifest -> manifest | None -> Location.raise_errorf ~loc "sexp_of_td/no-manifest" in let ty_dst = replace_variables_by_underscores manifest in let coercion = [%expr (v : [%t ty_src] :> [%t ty_dst]) ] in match body with | Fun fun_expr -> [%expr fun v -> [%e fun_expr] [%e coercion] ] | Match matchings -> [%expr fun v -> [%e pexp_match ~loc coercion matchings]] else match body with (* Prevent violation of value restriction and problems with recursive types by eta-expanding function definitions *) | Fun fun_expr -> [%expr fun v -> [%e fun_expr] v ] | Match matchings -> pexp_function ~loc matchings in let typ = Sig_generate_sexp_of.mk_type td in let func_name = "sexp_of_" ^ type_name in let body = let patts = List.map tps ~f:(fun id -> pvar ~loc ("_of_" ^ id)) in eabstract ~loc patts body in [constrained_function_binding loc td typ ~tps ~func_name body] let sexp_of_tds ~loc ~path:_ (rec_flag, tds) = let rec_flag = really_recursive rec_flag tds in let bindings = List.map tds ~f:sexp_of_td |> List.concat in [pstr_value ~loc rec_flag bindings] let sexp_of_exn ~loc:_ ~path ec = let renaming = Renaming.identity in let get_full_cnstr str = path ^ "." ^ str in let loc = ec.pext_name.loc in let expr = match ec with | {pext_name = {loc; txt = cnstr}; pext_kind = Pext_decl ([], None); _;} -> [%expr Sexplib.Exn_magic.register [%e pexp_construct ~loc (Located.lident ~loc cnstr) None] [%e estring ~loc (get_full_cnstr cnstr)] ] | {pext_name = {loc; txt = cnstr}; pext_kind = Pext_decl (_::_ as tps, None); _;} -> let fps = List.map ~f:(fun tp -> sexp_of_type renaming tp) tps in let sexp_converters = List.map fps ~f:Fun_or_match.(expr ~loc) in let _, patts, vars = Fun_or_match.map_tmp_vars ~loc fps in let qualified_reg_name = let open Longident in pexp_ident ~loc (Location.mkloc ( Ldot (Ldot (Lident "Sexplib", "Exn_magic"), Printf.sprintf "register%d" (List.length fps))) loc) in let make_exc = eabstract ~loc patts (pexp_construct ~loc (Located.lident ~loc cnstr) (Some (pexp_tuple ~loc vars))) in let call = let partial = [%expr [%e qualified_reg_name] [%e make_exc] [%e estring ~loc (get_full_cnstr cnstr)] ] in eapply ~loc partial sexp_converters in [%expr [%e call] ] | { pext_kind = Pext_decl (_, Some _); _} -> Location.raise_errorf ~loc "sexp_of_exn/:" | { pext_kind = Pext_rebind _; _} -> Location.raise_errorf ~loc "sexp_of_exn/rebind" in [ pstr_value ~loc Nonrecursive [value_binding ~loc ~pat:[%pat? ()] ~expr] ] end module Str_generate_of_sexp = struct (* Utility functions for polymorphic variants *) (* Handle backtracking when variants do not match *) let handle_no_variant_match loc expr = [[%pat? Sexplib.Conv_error.No_variant_match _] --> expr] (* Generate code depending on whether to generate a match for the last case of matching a variant *) let handle_variant_match_last loc ~match_last matches = match match_last, matches with | true, [{pc_lhs = _; pc_guard = None; pc_rhs = expr}] | _, [{pc_lhs = [%pat? _]; pc_guard = None; pc_rhs = expr}] -> expr | _ -> pexp_match ~loc [%expr atom] matches (* Generate code for matching malformed S-expressions *) let mk_variant_other_matches loc rev_els call = let coll_structs acc (loc, cnstr) = pstring ~loc cnstr --> (match call with | `ptag_no_args -> [%expr Sexplib.Conv_error.ptag_no_args _tp_loc _sexp] | `ptag_takes_args -> [%expr Sexplib.Conv_error.ptag_takes_args _tp_loc _sexp]) :: acc in let exc_no_variant_match = [%pat? _] --> [%expr Sexplib.Conv_error.no_variant_match _tp_loc _sexp] in List.fold_left ~f:coll_structs ~init:[exc_no_variant_match] rev_els (* Split the row fields of a variant type into lists of atomic variants, structured variants, atomic variants + included variant types, and structured variants + included variant types. *) let split_row_field ~loc (atoms, structs, ainhs, sinhs) row_field = match row_field with | Rtag (cnstr,_,true,[]) -> let tpl = loc, cnstr in ( tpl :: atoms, structs, `A tpl :: ainhs, sinhs ) | Rtag (cnstr,_,false,[tp]) -> let loc = tp.ptyp_loc in ( atoms, (loc, cnstr) :: structs, ainhs, `S (loc, cnstr, tp) :: sinhs ) | Rinherit inh -> let iinh = `I inh in ( atoms, structs, iinh :: ainhs, iinh :: sinhs ) | Rtag (_,_,true,[_]) | Rtag (_,_,_,_::_::_) -> Location.raise_errorf ~loc "split_row_field/&" | Rtag (_,_,false,[]) -> assert false (* Conversion of type paths *) let path_of_sexp_fun ?(internal=false) (id : Longident.t Located.t) = let map_name s = let s = s ^ "_of_sexp" in if internal then "__" ^ s ^ "__" else s in let txt : Longident.t = match id.txt with | Lident s -> Lident (map_name s) | Ldot (p, s) -> Ldot (p, map_name s) | Lapply _ -> failwith "Ppx_sexp_conv_expander.Str_generate_of_sexp.path_of_sexp_fun" in pexp_ident ~loc:id.loc { id with txt } (* Conversion of types *) let rec type_of_sexp ?(internal=false) typ : Fun_or_match.t = let loc = typ.ptyp_loc in match typ with | [%type: [%t? _] sexp_opaque ] | [%type: _ ] -> Fun [%expr Sexplib.Conv.opaque_of_sexp ] (*| [%type: sexp_option ] -> (* will never match surely! *) Fun [%expr fun a_of_sexp v -> Some (a_of_sexp v) ]*) | [%type: [%t? ty1] sexp_list ] -> let arg1 = Fun_or_match.expr ~loc (type_of_sexp ty1) in Fun [%expr (fun a_of_sexp v -> Sexplib.Conv.list_of_sexp a_of_sexp v) [%e arg1]] | [%type: [%t? ty1] sexp_array ] -> let arg1 = Fun_or_match.expr ~loc (type_of_sexp ty1) in Fun [%expr (fun a_of_sexp v -> Sexplib.Conv.array_of_sexp a_of_sexp v) [%e arg1] ] | { ptyp_desc = Ptyp_tuple tp; _ } -> Match (tuple_of_sexp (loc,tp)) | { ptyp_desc = Ptyp_var parm; _ } -> Fun (evar ~loc ("_of_" ^ parm)) | { ptyp_desc = Ptyp_constr (id, args); _ } -> let init = path_of_sexp_fun ~internal id in let args = List.map args ~f:(fun arg -> Fun_or_match.expr ~loc (type_of_sexp arg)) in Fun (eapply ~loc init args) | { ptyp_desc = Ptyp_arrow (_,_,_); _ } -> Fun [%expr Sexplib.Conv.fun_of_sexp ] | { ptyp_desc = Ptyp_variant (row_fields, _, _); _ } -> variant_of_sexp ?full_type:None (loc,row_fields) | { ptyp_desc = Ptyp_poly (parms, poly_tp); _ } -> poly_of_sexp parms poly_tp | { ptyp_desc = Ptyp_object (_, _); _ } | { ptyp_desc = Ptyp_class (_, _); _ } | { ptyp_desc = Ptyp_alias (_, _); _ } | { ptyp_desc = Ptyp_package _; _ } | { ptyp_desc = Ptyp_extension _; _ } -> Location.raise_errorf ~loc "unknown type" (* Conversion of tuples *) and tuple_of_sexp (loc,tps) = let fps = List.map ~f:type_of_sexp tps in let bindings, patts, vars = Fun_or_match.map_tmp_vars ~loc fps in let n = List.length fps in [ [%pat? Sexplib.Sexp.List [%p plist ~loc patts]] --> pexp_let ~loc Nonrecursive bindings (pexp_tuple ~loc vars) ; [%pat? sexp] --> [%expr Sexplib.Conv_error.tuple_of_size_n_expected _tp_loc [%e eint ~loc n] sexp] ] (* Generate code for matching included variant types *) and handle_variant_inh full_type ~match_last other_matches inh = let loc = inh.ptyp_loc in let func_expr = type_of_sexp ~internal:true inh in let app : Fun_or_match.t = let fun_expr = Fun_or_match.expr ~loc func_expr in Fun [%expr [%e fun_expr] _sexp] in let match_exc = handle_no_variant_match loc ( handle_variant_match_last loc ~match_last other_matches) in let new_other_matches = [ [%pat? _] --> pexp_try ~loc [%expr ([%e Fun_or_match.expr ~loc app] :> [%t replace_variables_by_underscores full_type])] match_exc ] in new_other_matches, true (* Generate code for matching atomic variants *) and mk_variant_match_atom loc full_type rev_atoms_inhs rev_structs = let coll (other_matches, match_last) = function | `A (loc, cnstr) -> let new_match = pstring ~loc cnstr --> pexp_variant ~loc cnstr None in new_match :: other_matches, false | `I inh -> handle_variant_inh full_type ~match_last other_matches inh in let other_matches = mk_variant_other_matches loc rev_structs `ptag_takes_args in let match_atoms_inhs, match_last = List.fold_left ~f:coll ~init:(other_matches, false) rev_atoms_inhs in handle_variant_match_last loc ~match_last match_atoms_inhs (* Variant conversions *) (* Match arguments of constructors (variants or sum types) *) and mk_cnstr_args_match ~loc ~is_variant cnstr tps = let cnstr vars_expr = if is_variant then pexp_variant ~loc cnstr (Some vars_expr) else pexp_construct ~loc (Located.lident ~loc cnstr) (Some vars_expr) in match tps with | [ [%type: [%t? tp] sexp_list ] ] -> let cnv = Fun_or_match.expr ~loc (type_of_sexp tp) in cnstr [%expr Sexplib.Conv.list_map ([%e cnv]) sexp_args ] | _ -> let bindings,patts,good_arg_match = let fps = List.map ~f:type_of_sexp tps in let bindings, patts, vars = Fun_or_match.map_tmp_vars ~loc fps in let good_arg_match = let vars_expr = match vars with | [var_expr] -> var_expr | _ -> pexp_tuple ~loc vars in cnstr vars_expr in bindings,patts,good_arg_match in [%expr match sexp_args with | [%p plist ~loc patts] -> [%e pexp_let ~loc Nonrecursive bindings good_arg_match] | _ -> [%e if is_variant then [%expr Sexplib.Conv_error.ptag_incorrect_n_args _tp_loc _tag _sexp] else [%expr Sexplib.Conv_error.stag_incorrect_n_args _tp_loc _tag _sexp]] ] (* Generate code for matching structured variants *) and mk_variant_match_struct loc full_type rev_structs_inhs rev_atoms = let has_structs_ref = ref false in let coll (other_matches, match_last) = function | `S (loc, cnstr, tp) -> has_structs_ref := true; let expr = mk_cnstr_args_match ~loc:tp.ptyp_loc ~is_variant:true cnstr [tp] in let new_match = [%pat? ([%p pstring ~loc cnstr] as _tag)] --> expr in new_match :: other_matches, false | `I inh -> handle_variant_inh full_type ~match_last other_matches inh in let other_matches = mk_variant_other_matches loc rev_atoms `ptag_no_args in let match_structs_inhs, match_last = List.fold_left ~f:coll ~init:(other_matches, false) rev_structs_inhs in ( handle_variant_match_last loc ~match_last match_structs_inhs, !has_structs_ref ) (* Generate code for handling atomic and structured variants (i.e. not included variant types) *) and handle_variant_tag loc full_type row_field_list = let rev_atoms, rev_structs, rev_atoms_inhs, rev_structs_inhs = List.fold_left ~f:(split_row_field ~loc) ~init:([], [], [], []) row_field_list in let match_struct, has_structs = mk_variant_match_struct loc full_type rev_structs_inhs rev_atoms in let maybe_sexp_args_patt = if has_structs then [%pat? sexp_args ] else [%pat? _ ] in [ [%pat? Sexplib.Sexp.Atom atom as _sexp] --> mk_variant_match_atom loc full_type rev_atoms_inhs rev_structs ; [%pat? Sexplib.Sexp.List (Sexplib.Sexp.Atom atom :: [%p maybe_sexp_args_patt]) as _sexp] --> match_struct ; [%pat? Sexplib.Sexp.List (Sexplib.Sexp.List _ :: _) as sexp] --> [%expr Sexplib.Conv_error.nested_list_invalid_poly_var _tp_loc sexp] ; [%pat? Sexplib.Sexp.List [] as sexp] --> [%expr Sexplib.Conv_error.empty_list_invalid_poly_var _tp_loc sexp] ] (* Generate matching code for variants *) and variant_of_sexp ?full_type (loc,row_fields) = let is_contained, full_type = match full_type with | None -> true, ptyp_variant ~loc row_fields Closed None | Some full_type -> false, full_type in let top_match = match row_fields with Rinherit inh :: rest -> let rec loop inh row_fields = let call = [%expr ( [%e Fun_or_match.expr ~loc (type_of_sexp ~internal:true inh)] sexp :> [%t replace_variables_by_underscores full_type] ) ] in match row_fields with | [] -> call | h :: t -> let expr = match h with | Rinherit inh -> loop inh t | _ -> let rftag_matches = handle_variant_tag loc full_type row_fields in pexp_match ~loc [%expr sexp] rftag_matches in pexp_try ~loc call (handle_no_variant_match loc expr) in [ [%pat? sexp] --> loop inh rest ] | _ :: _ -> handle_variant_tag loc full_type row_fields | [] -> assert false (* impossible *) in if is_contained then Fun [%expr fun sexp -> try [%e pexp_match ~loc [%expr sexp] top_match] with Sexplib.Conv_error.No_variant_match (_tp_loc, sexp) -> Sexplib.Conv_error.no_matching_variant_found _tp_loc sexp ] else Match top_match and poly_of_sexp parms tp = let loc = tp.ptyp_loc in let bindings = let mk_binding parm = value_binding ~loc ~pat:(pvar ~loc ("_of_" ^ parm)) ~expr:[%expr fun sexp -> Sexplib.Conv_error.record_poly_field_value _tp_loc sexp] in List.map ~f:mk_binding parms in match type_of_sexp tp with | Fun fun_expr -> Fun (pexp_let ~loc Nonrecursive bindings fun_expr) | Match matchings -> Match [ [%pat? arg] --> pexp_let ~loc Nonrecursive bindings (pexp_match ~loc [%expr arg] matchings) ] (* Sum type conversions *) (* Generate matching code for well-formed S-expressions wrt. sum types *) let mk_good_sum_matches (loc,cds) = List.map cds ~f:(function | { pcd_name = cnstr; pcd_args = []; _} -> let lcstr = pstring ~loc (String.uncapitalize cnstr.txt) in let str = pstring ~loc cnstr.txt in [%pat? Sexplib.Sexp.Atom ([%p lcstr] | [%p str])] --> pexp_construct ~loc (Located.lident ~loc cnstr.txt) None | { pcd_name = cnstr; pcd_args = (_::_ as tps); _} -> let lcstr = pstring ~loc (String.uncapitalize cnstr.txt) in let str = pstring ~loc cnstr.txt in [%pat? (Sexplib.Sexp.List (Sexplib.Sexp.Atom ([%p lcstr] | [%p str] as _tag) :: sexp_args) as _sexp) ] --> mk_cnstr_args_match ~loc ~is_variant:false cnstr.txt tps ) (* Generate matching code for malformed S-expressions with good tags wrt. sum types *) let mk_bad_sum_matches (loc,cds) = List.map cds ~f:(function | { pcd_name = cnstr; pcd_args = []; _} -> let lcstr = pstring ~loc (String.uncapitalize cnstr.txt) in let str = pstring ~loc cnstr.txt in [%pat? Sexplib.Sexp.List (Sexplib.Sexp.Atom ([%p lcstr] | [%p str]) :: _) as sexp ] --> [%expr Sexplib.Conv_error.stag_no_args _tp_loc sexp] | { pcd_name = cnstr; pcd_args = _::_; _} -> let lcstr = pstring ~loc (String.uncapitalize cnstr.txt) in let str = pstring ~loc cnstr.txt in [%pat? Sexplib.Sexp.Atom ([%p lcstr] | [%p str]) as sexp] --> [%expr Sexplib.Conv_error.stag_takes_args _tp_loc sexp] ) (* Generate matching code for sum types *) let sum_of_sexp (loc,alts) : Fun_or_match.t = Match (List.concat [ mk_good_sum_matches (loc,alts); mk_bad_sum_matches (loc,alts); [ [%pat? Sexplib.Sexp.List (Sexplib.Sexp.List _ :: _) as sexp] --> [%expr Sexplib.Conv_error.nested_list_invalid_sum _tp_loc sexp] ; [%pat? Sexplib.Sexp.List [] as sexp] --> [%expr Sexplib.Conv_error.empty_list_invalid_sum _tp_loc sexp] ; [%pat? sexp] --> [%expr Sexplib.Conv_error.unexpected_stag _tp_loc sexp] ] ]) (* Record conversions *) (* Generate code for extracting record fields *) let mk_extract_fields (loc,flds) = let rec loop no_args args = function | {pld_name = {txt=nm; loc}; pld_type = [%type: sexp_bool ] ; _ } :: more_flds -> let no_args = (pstring ~loc nm --> [%expr if ! [%e evar ~loc (nm ^ "_field")] then duplicates := ( field_name :: !duplicates ) else [%e evar ~loc (nm ^ "_field")] := true ] ) :: no_args in loop no_args args more_flds | {pld_name = {txt=nm; loc}; pld_type = [%type: [%t? tp] sexp_option ] ; _ } :: more_flds | {pld_name = {txt=nm; loc}; pld_type = tp; _ } :: more_flds -> let unrolled = Fun_or_match.unroll ~loc [%expr _field_sexp ] (type_of_sexp tp) in let args = (pstring ~loc nm --> [%expr match ! [%e evar ~loc (nm ^ "_field")] with | None -> let fvalue = [%e unrolled] in [%e evar ~loc (nm ^ "_field")] := Some fvalue | Some _ -> duplicates := (field_name :: ! duplicates) ] ) :: args in loop no_args args more_flds | [] -> no_args,args in let handle_extra = [ [%pat? _] --> [%expr if !Sexplib.Conv.record_check_extra_fields then extra := (field_name :: !extra) else ()] ] in loop handle_extra handle_extra (List.rev flds) (* Generate code for handling the result of matching record fields *) let mk_handle_record_match_result has_poly (loc,flds) = let has_nonopt_fields = ref false in let res_tpls, bi_lst, good_patts = let rec loop ((res_tpls, bi_lst, good_patts) as acc) = function | {pld_name = {txt=nm; loc}; pld_type = tp; _ } as ld :: more_flds -> let fld = [%expr ! [%e evar ~loc (nm ^ "_field")]] in let mk_default loc = bi_lst, [%pat? [%p pvar ~loc (nm ^ "_value")] ] :: good_patts in let new_bi_lst, new_good_patts = match tp with | [%type: sexp_bool ] | [%type: [%t? _] sexp_option ] | [%type: [%t? _] sexp_list ] | [%type: [%t? _] sexp_array ] -> mk_default loc | _ -> match Attribute.get Attrs.default ld with | Some _ -> mk_default loc | None -> has_nonopt_fields := true; ( [%expr (Pervasives.(=) [%e fld] None, [%e estring ~loc nm]) ] :: bi_lst, [%pat? Some [%p pvar ~loc (nm ^ "_value")] ] :: good_patts ) in let acc =( [%expr [%e fld] ] :: res_tpls, new_bi_lst, new_good_patts ) in loop acc more_flds | [] -> acc in loop ([], [], []) (List.rev flds) in let match_good_expr = if has_poly then let cnvt = function | {pld_name = {txt=nm; _}; _ } -> evar ~loc (nm ^ "_value") in match List.map ~f:cnvt flds with | [match_good_expr] -> match_good_expr | match_good_exprs -> pexp_tuple ~loc match_good_exprs else let cnvt = function | {pld_name = {txt=nm; _}; pld_type = [%type: [%t? _] sexp_list ]; _ } -> (Located.lident ~loc nm), [%expr match [%e evar ~loc (nm ^ "_value")] with | None -> [] | Some v -> v ] | {pld_name = {txt=nm; _}; pld_type = [%type: [%t? _] sexp_array ]; _ } -> (Located.lident ~loc nm), [%expr match [%e evar ~loc (nm ^ "_value")] with | None -> [||] | Some v -> v ] | {pld_name = {txt=nm; _}; _ } as ld -> begin match Attribute.get Attrs.default ld with | None -> Located.lident ~loc nm, evar ~loc (nm ^ "_value") | Some default -> Located.lident ~loc nm, [%expr match [%e evar ~loc (nm ^ "_value")] with None -> [%e default] | Some v -> v ] end in pexp_record ~loc (List.map ~f:cnvt flds) None in let expr, patt = match res_tpls, good_patts with | [res_expr], [res_patt] -> res_expr, res_patt | _ -> pexp_tuple ~loc res_tpls, ppat_tuple ~loc good_patts in if !has_nonopt_fields then pexp_match ~loc expr [ patt --> match_good_expr ; [%pat? _] --> [%expr Sexplib.Conv_error.record_undefined_elements _tp_loc sexp [%e elist ~loc bi_lst] ] ] else pexp_match ~loc expr [ patt --> match_good_expr ] (* Generate code for converting record fields *) let mk_cnv_fields has_poly (loc,flds) = let field_refs = List.map flds ~f:(function | {pld_name = {txt=name; loc}; pld_type = [%type: sexp_bool]; _ } -> value_binding ~loc ~pat:(pvar ~loc (name ^ "_field")) ~expr:[%expr ref false] | {pld_name = {txt=name; loc}; _ } -> value_binding ~loc ~pat:(pvar ~loc (name ^ "_field")) ~expr:[%expr ref None] ) in let mc_no_args_fields, mc_fields_with_args = mk_extract_fields (loc,flds) in pexp_let ~loc Nonrecursive (field_refs @ [ value_binding ~loc ~pat:[%pat? duplicates] ~expr:[%expr ref []]; value_binding ~loc ~pat:[%pat? extra] ~expr:[%expr ref []]; ]) [%expr let rec iter = [%e pexp_function ~loc [ [%pat? Sexplib.Sexp.List [(Sexplib.Sexp.Atom field_name); _field_sexp] :: tail] --> [%expr [%e pexp_match ~loc [%expr field_name] mc_fields_with_args]; iter tail] ; [%pat? Sexplib.Sexp.List [(Sexplib.Sexp.Atom field_name)] :: tail] --> [%expr [%e pexp_match ~loc [%expr field_name] mc_no_args_fields]; iter tail] ; [%pat? ((Sexplib.Sexp.Atom _ | Sexplib.Sexp.List _) as sexp) :: _] --> [%expr Sexplib.Conv_error.record_only_pairs_expected _tp_loc sexp] ; [%pat? []] --> [%expr ()] ] ] in iter field_sexps; if Pervasives.(<>) (!duplicates) [] then Sexplib.Conv_error.record_duplicate_fields _tp_loc (!duplicates) sexp else if Pervasives.(<>) (!extra) [] then Sexplib.Conv_error.record_extra_fields _tp_loc (!extra) sexp else [%e mk_handle_record_match_result has_poly (loc,flds)] ] let is_poly (_,flds) = List.exists flds ~f:(function | { pld_type = {ptyp_desc = Ptyp_poly _; _ }; _} -> true | _ -> false) (* Generate matching code for records *) let record_of_sexp (loc,flds) : Fun_or_match.t = let handle_fields = let has_poly = is_poly (loc,flds) in let cnv_fields = mk_cnv_fields has_poly (loc,flds) in if has_poly then let patt = let pats = List.map flds ~f:(fun {pld_name = {txt=name; loc}; _ } -> pvar ~loc name ) in match pats with | [pat] -> pat | pats -> ppat_tuple ~loc pats in let record_def = pexp_record ~loc ( List.map flds ~f:(fun {pld_name = {txt=name; loc}; _ } -> (Located.lident ~loc name, evar ~loc name) )) None in pexp_let ~loc Nonrecursive [value_binding ~loc ~pat:patt ~expr:cnv_fields] record_def else cnv_fields in Match [ [%pat? Sexplib.Sexp.List field_sexps as sexp] --> handle_fields ; [%pat? Sexplib.Sexp.Atom _ as sexp] --> [%expr Sexplib.Conv_error.record_list_instead_atom _tp_loc sexp] ] (* Empty type *) let nil_of_sexp loc : Fun_or_match.t = Fun [%expr fun sexp -> Sexplib.Conv_error.empty_type _tp_loc sexp ] (* Generate code from type definitions *) let td_of_sexp ~loc:_ ~poly ~path td = let td = name_type_params_in_td td in let tps = List.map td.ptype_params ~f:(fun tp -> (get_type_param_name tp).txt) in let {ptype_name = {txt = type_name; loc = _}; ptype_loc = loc; _} = td in let full_type = core_type_of_type_declaration td |> replace_variables_by_underscores in let is_private = (match td.ptype_private with Private -> true | Public -> false) in if is_private then Location.raise_errorf ~loc "of_sexp is not supported for private type"; let create_internal_function = match is_polymorphic_variant td ~sig_:false with | `Definitely -> true | `Maybe -> poly | `Surely_not -> if poly then Location.raise_errorf ~loc "sexp_poly annotation on a type that is surely not a polymorphic variant"; false in let body = let body = match td.ptype_kind with | Ptype_variant alts -> sum_of_sexp (td.ptype_loc, alts) | Ptype_record lbls -> record_of_sexp (loc, lbls) | Ptype_open -> Location.raise_errorf ~loc "ppx_sexp_conv: open types not supported" | Ptype_abstract -> match td.ptype_manifest with | None -> nil_of_sexp td.ptype_loc | Some { ptyp_desc = Ptyp_variant (rows, _, _); _ } -> variant_of_sexp ~full_type (loc, rows) | Some ty -> type_of_sexp ~internal:create_internal_function ty in match body with (* Prevent violation of value restriction and problems with recursive types by eta-expanding function definitions *) | Fun fun_expr -> [%expr fun t -> [%e fun_expr] t ] | Match matchings -> pexp_function ~loc matchings in let external_name = type_name ^ "_of_sexp" in let internal_name = "__" ^ type_name ^ "_of_sexp__" in let arg_patts, arg_exprs = List.split ( List.map ~f:(fun tp -> let name = "_of_" ^ tp in pvar ~loc name, evar ~loc name) tps) in let bind_tp_loc_in = let full_type_name = Printf.sprintf "%s.%s" path type_name in (fun e -> [%expr let _tp_loc = [%e estring ~loc full_type_name] in [%e e]]) in let internal_fun_body = if create_internal_function then Some (bind_tp_loc_in (eabstract ~loc arg_patts body)) else None in let external_fun_body = let need_tp_loc, body_below_lambdas = if create_internal_function then let no_variant_match_mc = [ [%pat? Sexplib.Conv_error.No_variant_match (_tp_loc, sexp)] --> [%expr Sexplib.Conv_error.no_matching_variant_found _tp_loc sexp] ] in let internal_call = let internal_expr = evar ~loc internal_name in eapply ~loc internal_expr (arg_exprs @ [ [%expr sexp] ]) in let try_with = pexp_try ~loc internal_call no_variant_match_mc in false, [%expr fun sexp -> [%e try_with]] else true, body in let body_with_lambdas = eabstract ~loc arg_patts body_below_lambdas in if need_tp_loc then bind_tp_loc_in body_with_lambdas else body_with_lambdas in let typ = Sig_generate_of_sexp.mk_type td in let mk_binding func_name body = constrained_function_binding loc td typ ~tps ~func_name body in let internal_bindings = match internal_fun_body with | None -> [] | Some body -> [mk_binding internal_name body] in let external_binding = mk_binding external_name external_fun_body in internal_bindings, [external_binding] (* Generate code from type definitions *) let tds_of_sexp ~loc ~poly ~path (rec_flag, tds) = begin (* special case for singleton type defs to match camlp4 *) let singleton = (match tds with [_] -> true | _ -> false) in if singleton then match really_recursive rec_flag tds with | Recursive -> let bindings = List.map tds ~f:(fun td -> let internals,externals = td_of_sexp ~loc ~poly ~path td in internals @ externals) |> List.concat in [pstr_value ~loc Recursive bindings] | Nonrecursive -> let bindings = List.map tds ~f:(fun td -> let internals,externals = td_of_sexp ~loc ~poly ~path td in [pstr_value ~loc Nonrecursive internals; pstr_value ~loc Nonrecursive externals]) |> List.concat in bindings else let bindings = List.map tds ~f:(fun td -> let internals,externals = td_of_sexp ~poly ~loc ~path td in internals @ externals) |> List.concat in [pstr_value ~loc rec_flag bindings] end let type_of_sexp ~path ctyp = let loc = ctyp.ptyp_loc in let fp = type_of_sexp ctyp in let body = match fp with | Fun fun_expr -> [%expr [%e fun_expr] sexp ] | Match matchings -> pexp_match ~loc [%expr sexp] matchings in let full_type_name = let _, line_num, _ = Location.get_pos_info loc.Location.loc_start in Printf.sprintf "%s line %i: %s" path line_num (string_of_core_type ctyp) in [%expr fun sexp -> let _tp_loc = [%e estring ~loc full_type_name] in [%e body] ] ;; end module Sexp_of = struct let core_type ty = Str_generate_sexp_of.sexp_of_type Renaming.identity ty |> Fun_or_match.expr ~loc:ty.ptyp_loc ;; let sig_type_decl = Sig_generate_sexp_of.mk_sig let sig_exception = Sig_generate_sexp_of.mk_sig_exn let str_type_decl = Str_generate_sexp_of.sexp_of_tds let str_exception = Str_generate_sexp_of.sexp_of_exn end module Of_sexp = struct let core_type = Str_generate_of_sexp.type_of_sexp let sig_type_decl = Sig_generate_of_sexp.mk_sig let str_type_decl = Str_generate_of_sexp.tds_of_sexp end ppx_sexp_conv-113.33.03/expander/ppx_sexp_conv_expander.mllib0000644002755601004200000000015312710357125023476 0ustar jdiminotech# OASIS_START # DO NOT EDIT (digest: 443e49a2f9e789b01ff01e160a0e5c71) Ppx_sexp_conv_expander # OASIS_STOP ppx_sexp_conv-113.33.03/expander/ppx_sexp_conv_expander.mldylib0000644002755601004200000000015312710357125024033 0ustar jdiminotech# OASIS_START # DO NOT EDIT (digest: 443e49a2f9e789b01ff01e160a0e5c71) Ppx_sexp_conv_expander # OASIS_STOP ppx_sexp_conv-113.33.03/expander/ppx_sexp_conv_expander.mli0000664002755601004200000000216712710355760023174 0ustar jdiminotechopen Asttypes open Parsetree open Ppx_core.Std module Attrs : sig val default : (label_declaration, expression) Attribute.t val drop_default : (label_declaration, unit ) Attribute.t val drop_if : (label_declaration, expression) Attribute.t end module Sexp_of : sig val core_type : core_type -> expression val sig_type_decl : loc:Location.t -> path:string -> rec_flag * type_declaration list -> signature val sig_exception : loc:Location.t -> path:string -> extension_constructor -> signature val str_type_decl : loc:Location.t -> path:string -> rec_flag * type_declaration list -> structure val str_exception : loc:Location.t -> path:string -> extension_constructor -> structure end module Of_sexp : sig val core_type : path:string -> core_type -> expression val sig_type_decl : poly:bool -> loc:Location.t -> path:string -> rec_flag * type_declaration list -> signature val str_type_decl : loc:Location.t -> poly:bool -> path:string -> rec_flag * type_declaration list -> structure end ppx_sexp_conv-113.33.03/_tags0000644002755601004200000000207112710357125015107 0ustar jdiminotech<**/*.ml{,i}>: warn(-40), no_alias_deps <**/*>: thread # This prevents the implicit addition of -ppx options by ocamlfind <**/*>: predicate(custom_ppx) : linkall # OASIS_START # DO NOT EDIT (digest: 6a3b086cc1a5df09f4fbdb1b5f9320ba) # Ignore VCS directories, you can use the same kind of rule outside # OASIS_START/STOP if you want to exclude directories that contains # useless stuff for the build process true: annot, bin_annot <**/.svn>: -traverse <**/.svn>: not_hygienic ".bzr": -traverse ".bzr": not_hygienic ".hg": -traverse ".hg": not_hygienic ".git": -traverse ".git": not_hygienic "_darcs": -traverse "_darcs": not_hygienic # Library ppx_sexp_conv_expander "expander/ppx_sexp_conv_expander.cmxs": use_ppx_sexp_conv_expander : package(ppx_core) : package(ppx_tools.metaquot) # Library ppx_sexp_conv "src/ppx_sexp_conv.cmxs": use_ppx_sexp_conv : package(ppx_core) : package(ppx_tools.metaquot) : package(ppx_type_conv) : use_ppx_sexp_conv_expander # OASIS_STOP ppx_sexp_conv-113.33.03/setup.ml0000644002755601004200000053060312710357125015570 0ustar jdiminotech(* OASIS_START *) (* DO NOT EDIT (digest: d7b8d25452dbb860c98411753de6cfd9) *) (* Regenerated by OASIS v0.4.5 Visit http://oasis.forge.ocamlcore.org for more information and documentation about functions used in this file. *) module OASISGettext = struct (* # 22 "src/oasis/OASISGettext.ml" *) let ns_ str = str let s_ str = str let f_ (str: ('a, 'b, 'c, 'd) format4) = str let fn_ fmt1 fmt2 n = if n = 1 then fmt1^^"" else fmt2^^"" let init = [] end module OASISContext = struct (* # 22 "src/oasis/OASISContext.ml" *) open OASISGettext type level = [ `Debug | `Info | `Warning | `Error] type t = { (* TODO: replace this by a proplist. *) quiet: bool; info: bool; debug: bool; ignore_plugins: bool; ignore_unknown_fields: bool; printf: level -> string -> unit; } let printf lvl str = let beg = match lvl with | `Error -> s_ "E: " | `Warning -> s_ "W: " | `Info -> s_ "I: " | `Debug -> s_ "D: " in prerr_endline (beg^str) let default = ref { quiet = false; info = false; debug = false; ignore_plugins = false; ignore_unknown_fields = false; printf = printf; } let quiet = {!default with quiet = true} let fspecs () = (* TODO: don't act on default. *) let ignore_plugins = ref false in ["-quiet", Arg.Unit (fun () -> default := {!default with quiet = true}), s_ " Run quietly"; "-info", Arg.Unit (fun () -> default := {!default with info = true}), s_ " Display information message"; "-debug", Arg.Unit (fun () -> default := {!default with debug = true}), s_ " Output debug message"; "-ignore-plugins", Arg.Set ignore_plugins, s_ " Ignore plugin's field."; "-C", (* TODO: remove this chdir. *) Arg.String (fun str -> Sys.chdir str), s_ "dir Change directory before running."], fun () -> {!default with ignore_plugins = !ignore_plugins} end module OASISString = struct (* # 22 "src/oasis/OASISString.ml" *) (** Various string utilities. Mostly inspired by extlib and batteries ExtString and BatString libraries. @author Sylvain Le Gall *) let nsplitf str f = if str = "" then [] else let buf = Buffer.create 13 in let lst = ref [] in let push () = lst := Buffer.contents buf :: !lst; Buffer.clear buf in let str_len = String.length str in for i = 0 to str_len - 1 do if f str.[i] then push () else Buffer.add_char buf str.[i] done; push (); List.rev !lst (** [nsplit c s] Split the string [s] at char [c]. It doesn't include the separator. *) let nsplit str c = nsplitf str ((=) c) let find ~what ?(offset=0) str = let what_idx = ref 0 in let str_idx = ref offset in while !str_idx < String.length str && !what_idx < String.length what do if str.[!str_idx] = what.[!what_idx] then incr what_idx else what_idx := 0; incr str_idx done; if !what_idx <> String.length what then raise Not_found else !str_idx - !what_idx let sub_start str len = let str_len = String.length str in if len >= str_len then "" else String.sub str len (str_len - len) let sub_end ?(offset=0) str len = let str_len = String.length str in if len >= str_len then "" else String.sub str 0 (str_len - len) let starts_with ~what ?(offset=0) str = let what_idx = ref 0 in let str_idx = ref offset in let ok = ref true in while !ok && !str_idx < String.length str && !what_idx < String.length what do if str.[!str_idx] = what.[!what_idx] then incr what_idx else ok := false; incr str_idx done; if !what_idx = String.length what then true else false let strip_starts_with ~what str = if starts_with ~what str then sub_start str (String.length what) else raise Not_found let ends_with ~what ?(offset=0) str = let what_idx = ref ((String.length what) - 1) in let str_idx = ref ((String.length str) - 1) in let ok = ref true in while !ok && offset <= !str_idx && 0 <= !what_idx do if str.[!str_idx] = what.[!what_idx] then decr what_idx else ok := false; decr str_idx done; if !what_idx = -1 then true else false let strip_ends_with ~what str = if ends_with ~what str then sub_end str (String.length what) else raise Not_found let replace_chars f s = let buf = Buffer.create (String.length s) in String.iter (fun c -> Buffer.add_char buf (f c)) s; Buffer.contents buf end module OASISUtils = struct (* # 22 "src/oasis/OASISUtils.ml" *) open OASISGettext module MapExt = struct module type S = sig include Map.S val add_list: 'a t -> (key * 'a) list -> 'a t val of_list: (key * 'a) list -> 'a t val to_list: 'a t -> (key * 'a) list end module Make (Ord: Map.OrderedType) = struct include Map.Make(Ord) let rec add_list t = function | (k, v) :: tl -> add_list (add k v t) tl | [] -> t let of_list lst = add_list empty lst let to_list t = fold (fun k v acc -> (k, v) :: acc) t [] end end module MapString = MapExt.Make(String) module SetExt = struct module type S = sig include Set.S val add_list: t -> elt list -> t val of_list: elt list -> t val to_list: t -> elt list end module Make (Ord: Set.OrderedType) = struct include Set.Make(Ord) let rec add_list t = function | e :: tl -> add_list (add e t) tl | [] -> t let of_list lst = add_list empty lst let to_list = elements end end module SetString = SetExt.Make(String) let compare_csl s1 s2 = String.compare (String.lowercase s1) (String.lowercase s2) module HashStringCsl = Hashtbl.Make (struct type t = string let equal s1 s2 = (String.lowercase s1) = (String.lowercase s2) let hash s = Hashtbl.hash (String.lowercase s) end) module SetStringCsl = SetExt.Make (struct type t = string let compare = compare_csl end) let varname_of_string ?(hyphen='_') s = if String.length s = 0 then begin invalid_arg "varname_of_string" end else begin let buf = OASISString.replace_chars (fun c -> if ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') then c else hyphen) s; in let buf = (* Start with a _ if digit *) if '0' <= s.[0] && s.[0] <= '9' then "_"^buf else buf in String.lowercase buf end let varname_concat ?(hyphen='_') p s = let what = String.make 1 hyphen in let p = try OASISString.strip_ends_with ~what p with Not_found -> p in let s = try OASISString.strip_starts_with ~what s with Not_found -> s in p^what^s let is_varname str = str = varname_of_string str let failwithf fmt = Printf.ksprintf failwith fmt end module PropList = struct (* # 22 "src/oasis/PropList.ml" *) open OASISGettext type name = string exception Not_set of name * string option exception No_printer of name exception Unknown_field of name * name let () = Printexc.register_printer (function | Not_set (nm, Some rsn) -> Some (Printf.sprintf (f_ "Field '%s' is not set: %s") nm rsn) | Not_set (nm, None) -> Some (Printf.sprintf (f_ "Field '%s' is not set") nm) | No_printer nm -> Some (Printf.sprintf (f_ "No default printer for value %s") nm) | Unknown_field (nm, schm) -> Some (Printf.sprintf (f_ "Field %s is not defined in schema %s") nm schm) | _ -> None) module Data = struct type t = (name, unit -> unit) Hashtbl.t let create () = Hashtbl.create 13 let clear t = Hashtbl.clear t (* # 78 "src/oasis/PropList.ml" *) end module Schema = struct type ('ctxt, 'extra) value = { get: Data.t -> string; set: Data.t -> ?context:'ctxt -> string -> unit; help: (unit -> string) option; extra: 'extra; } type ('ctxt, 'extra) t = { name: name; fields: (name, ('ctxt, 'extra) value) Hashtbl.t; order: name Queue.t; name_norm: string -> string; } let create ?(case_insensitive=false) nm = { name = nm; fields = Hashtbl.create 13; order = Queue.create (); name_norm = (if case_insensitive then String.lowercase else fun s -> s); } let add t nm set get extra help = let key = t.name_norm nm in if Hashtbl.mem t.fields key then failwith (Printf.sprintf (f_ "Field '%s' is already defined in schema '%s'") nm t.name); Hashtbl.add t.fields key { set = set; get = get; help = help; extra = extra; }; Queue.add nm t.order let mem t nm = Hashtbl.mem t.fields nm let find t nm = try Hashtbl.find t.fields (t.name_norm nm) with Not_found -> raise (Unknown_field (nm, t.name)) let get t data nm = (find t nm).get data let set t data nm ?context x = (find t nm).set data ?context x let fold f acc t = Queue.fold (fun acc k -> let v = find t k in f acc k v.extra v.help) acc t.order let iter f t = fold (fun () -> f) () t let name t = t.name end module Field = struct type ('ctxt, 'value, 'extra) t = { set: Data.t -> ?context:'ctxt -> 'value -> unit; get: Data.t -> 'value; sets: Data.t -> ?context:'ctxt -> string -> unit; gets: Data.t -> string; help: (unit -> string) option; extra: 'extra; } let new_id = let last_id = ref 0 in fun () -> incr last_id; !last_id let create ?schema ?name ?parse ?print ?default ?update ?help extra = (* Default value container *) let v = ref None in (* If name is not given, create unique one *) let nm = match name with | Some s -> s | None -> Printf.sprintf "_anon_%d" (new_id ()) in (* Last chance to get a value: the default *) let default () = match default with | Some d -> d | None -> raise (Not_set (nm, Some (s_ "no default value"))) in (* Get data *) let get data = (* Get value *) try (Hashtbl.find data nm) (); match !v with | Some x -> x | None -> default () with Not_found -> default () in (* Set data *) let set data ?context x = let x = match update with | Some f -> begin try f ?context (get data) x with Not_set _ -> x end | None -> x in Hashtbl.replace data nm (fun () -> v := Some x) in (* Parse string value, if possible *) let parse = match parse with | Some f -> f | None -> fun ?context s -> failwith (Printf.sprintf (f_ "Cannot parse field '%s' when setting value %S") nm s) in (* Set data, from string *) let sets data ?context s = set ?context data (parse ?context s) in (* Output value as string, if possible *) let print = match print with | Some f -> f | None -> fun _ -> raise (No_printer nm) in (* Get data, as a string *) let gets data = print (get data) in begin match schema with | Some t -> Schema.add t nm sets gets extra help | None -> () end; { set = set; get = get; sets = sets; gets = gets; help = help; extra = extra; } let fset data t ?context x = t.set data ?context x let fget data t = t.get data let fsets data t ?context s = t.sets data ?context s let fgets data t = t.gets data end module FieldRO = struct let create ?schema ?name ?parse ?print ?default ?update ?help extra = let fld = Field.create ?schema ?name ?parse ?print ?default ?update ?help extra in fun data -> Field.fget data fld end end module OASISMessage = struct (* # 22 "src/oasis/OASISMessage.ml" *) open OASISGettext open OASISContext let generic_message ~ctxt lvl fmt = let cond = if ctxt.quiet then false else match lvl with | `Debug -> ctxt.debug | `Info -> ctxt.info | _ -> true in Printf.ksprintf (fun str -> if cond then begin ctxt.printf lvl str end) fmt let debug ~ctxt fmt = generic_message ~ctxt `Debug fmt let info ~ctxt fmt = generic_message ~ctxt `Info fmt let warning ~ctxt fmt = generic_message ~ctxt `Warning fmt let error ~ctxt fmt = generic_message ~ctxt `Error fmt end module OASISVersion = struct (* # 22 "src/oasis/OASISVersion.ml" *) open OASISGettext type s = string type t = string type comparator = | VGreater of t | VGreaterEqual of t | VEqual of t | VLesser of t | VLesserEqual of t | VOr of comparator * comparator | VAnd of comparator * comparator (* Range of allowed characters *) let is_digit c = '0' <= c && c <= '9' let is_alpha c = ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') let is_special = function | '.' | '+' | '-' | '~' -> true | _ -> false let rec version_compare v1 v2 = if v1 <> "" || v2 <> "" then begin (* Compare ascii string, using special meaning for version * related char *) let val_ascii c = if c = '~' then -1 else if is_digit c then 0 else if c = '\000' then 0 else if is_alpha c then Char.code c else (Char.code c) + 256 in let len1 = String.length v1 in let len2 = String.length v2 in let p = ref 0 in (** Compare ascii part *) let compare_vascii () = let cmp = ref 0 in while !cmp = 0 && !p < len1 && !p < len2 && not (is_digit v1.[!p] && is_digit v2.[!p]) do cmp := (val_ascii v1.[!p]) - (val_ascii v2.[!p]); incr p done; if !cmp = 0 && !p < len1 && !p = len2 then val_ascii v1.[!p] else if !cmp = 0 && !p = len1 && !p < len2 then - (val_ascii v2.[!p]) else !cmp in (** Compare digit part *) let compare_digit () = let extract_int v p = let start_p = !p in while !p < String.length v && is_digit v.[!p] do incr p done; let substr = String.sub v !p ((String.length v) - !p) in let res = match String.sub v start_p (!p - start_p) with | "" -> 0 | s -> int_of_string s in res, substr in let i1, tl1 = extract_int v1 (ref !p) in let i2, tl2 = extract_int v2 (ref !p) in i1 - i2, tl1, tl2 in match compare_vascii () with | 0 -> begin match compare_digit () with | 0, tl1, tl2 -> if tl1 <> "" && is_digit tl1.[0] then 1 else if tl2 <> "" && is_digit tl2.[0] then -1 else version_compare tl1 tl2 | n, _, _ -> n end | n -> n end else begin 0 end let version_of_string str = str let string_of_version t = t let version_compare_string s1 s2 = version_compare (version_of_string s1) (version_of_string s2) let chop t = try let pos = String.rindex t '.' in String.sub t 0 pos with Not_found -> t let rec comparator_apply v op = match op with | VGreater cv -> (version_compare v cv) > 0 | VGreaterEqual cv -> (version_compare v cv) >= 0 | VLesser cv -> (version_compare v cv) < 0 | VLesserEqual cv -> (version_compare v cv) <= 0 | VEqual cv -> (version_compare v cv) = 0 | VOr (op1, op2) -> (comparator_apply v op1) || (comparator_apply v op2) | VAnd (op1, op2) -> (comparator_apply v op1) && (comparator_apply v op2) let rec string_of_comparator = function | VGreater v -> "> "^(string_of_version v) | VEqual v -> "= "^(string_of_version v) | VLesser v -> "< "^(string_of_version v) | VGreaterEqual v -> ">= "^(string_of_version v) | VLesserEqual v -> "<= "^(string_of_version v) | VOr (c1, c2) -> (string_of_comparator c1)^" || "^(string_of_comparator c2) | VAnd (c1, c2) -> (string_of_comparator c1)^" && "^(string_of_comparator c2) let rec varname_of_comparator = let concat p v = OASISUtils.varname_concat p (OASISUtils.varname_of_string (string_of_version v)) in function | VGreater v -> concat "gt" v | VLesser v -> concat "lt" v | VEqual v -> concat "eq" v | VGreaterEqual v -> concat "ge" v | VLesserEqual v -> concat "le" v | VOr (c1, c2) -> (varname_of_comparator c1)^"_or_"^(varname_of_comparator c2) | VAnd (c1, c2) -> (varname_of_comparator c1)^"_and_"^(varname_of_comparator c2) let rec comparator_ge v' = let cmp v = version_compare v v' >= 0 in function | VEqual v | VGreaterEqual v | VGreater v -> cmp v | VLesserEqual _ | VLesser _ -> false | VOr (c1, c2) -> comparator_ge v' c1 || comparator_ge v' c2 | VAnd (c1, c2) -> comparator_ge v' c1 && comparator_ge v' c2 end module OASISLicense = struct (* # 22 "src/oasis/OASISLicense.ml" *) (** License for _oasis fields @author Sylvain Le Gall *) type license = string type license_exception = string type license_version = | Version of OASISVersion.t | VersionOrLater of OASISVersion.t | NoVersion type license_dep_5_unit = { license: license; excption: license_exception option; version: license_version; } type license_dep_5 = | DEP5Unit of license_dep_5_unit | DEP5Or of license_dep_5 list | DEP5And of license_dep_5 list type t = | DEP5License of license_dep_5 | OtherLicense of string (* URL *) end module OASISExpr = struct (* # 22 "src/oasis/OASISExpr.ml" *) open OASISGettext type test = string type flag = string type t = | EBool of bool | ENot of t | EAnd of t * t | EOr of t * t | EFlag of flag | ETest of test * string type 'a choices = (t * 'a) list let eval var_get t = let rec eval' = function | EBool b -> b | ENot e -> not (eval' e) | EAnd (e1, e2) -> (eval' e1) && (eval' e2) | EOr (e1, e2) -> (eval' e1) || (eval' e2) | EFlag nm -> let v = var_get nm in assert(v = "true" || v = "false"); (v = "true") | ETest (nm, vl) -> let v = var_get nm in (v = vl) in eval' t let choose ?printer ?name var_get lst = let rec choose_aux = function | (cond, vl) :: tl -> if eval var_get cond then vl else choose_aux tl | [] -> let str_lst = if lst = [] then s_ "" else String.concat (s_ ", ") (List.map (fun (cond, vl) -> match printer with | Some p -> p vl | None -> s_ "") lst) in match name with | Some nm -> failwith (Printf.sprintf (f_ "No result for the choice list '%s': %s") nm str_lst) | None -> failwith (Printf.sprintf (f_ "No result for a choice list: %s") str_lst) in choose_aux (List.rev lst) end module OASISText = struct (* # 22 "src/oasis/OASISText.ml" *) type elt = | Para of string | Verbatim of string | BlankLine type t = elt list end module OASISTypes = struct (* # 22 "src/oasis/OASISTypes.ml" *) type name = string type package_name = string type url = string type unix_dirname = string type unix_filename = string type host_dirname = string type host_filename = string type prog = string type arg = string type args = string list type command_line = (prog * arg list) type findlib_name = string type findlib_full = string type compiled_object = | Byte | Native | Best type dependency = | FindlibPackage of findlib_full * OASISVersion.comparator option | InternalLibrary of name type tool = | ExternalTool of name | InternalExecutable of name type vcs = | Darcs | Git | Svn | Cvs | Hg | Bzr | Arch | Monotone | OtherVCS of url type plugin_kind = [ `Configure | `Build | `Doc | `Test | `Install | `Extra ] type plugin_data_purpose = [ `Configure | `Build | `Install | `Clean | `Distclean | `Install | `Uninstall | `Test | `Doc | `Extra | `Other of string ] type 'a plugin = 'a * name * OASISVersion.t option type all_plugin = plugin_kind plugin type plugin_data = (all_plugin * plugin_data_purpose * (unit -> unit)) list (* # 115 "src/oasis/OASISTypes.ml" *) type 'a conditional = 'a OASISExpr.choices type custom = { pre_command: (command_line option) conditional; post_command: (command_line option) conditional; } type common_section = { cs_name: name; cs_data: PropList.Data.t; cs_plugin_data: plugin_data; } type build_section = { bs_build: bool conditional; bs_install: bool conditional; bs_path: unix_dirname; bs_compiled_object: compiled_object; bs_build_depends: dependency list; bs_build_tools: tool list; bs_c_sources: unix_filename list; bs_data_files: (unix_filename * unix_filename option) list; bs_ccopt: args conditional; bs_cclib: args conditional; bs_dlllib: args conditional; bs_dllpath: args conditional; bs_byteopt: args conditional; bs_nativeopt: args conditional; } type library = { lib_modules: string list; lib_pack: bool; lib_internal_modules: string list; lib_findlib_parent: findlib_name option; lib_findlib_name: findlib_name option; lib_findlib_containers: findlib_name list; } type object_ = { obj_modules: string list; obj_findlib_fullname: findlib_name list option; } type executable = { exec_custom: bool; exec_main_is: unix_filename; } type flag = { flag_description: string option; flag_default: bool conditional; } type source_repository = { src_repo_type: vcs; src_repo_location: url; src_repo_browser: url option; src_repo_module: string option; src_repo_branch: string option; src_repo_tag: string option; src_repo_subdir: unix_filename option; } type test = { test_type: [`Test] plugin; test_command: command_line conditional; test_custom: custom; test_working_directory: unix_filename option; test_run: bool conditional; test_tools: tool list; } type doc_format = | HTML of unix_filename | DocText | PDF | PostScript | Info of unix_filename | DVI | OtherDoc type doc = { doc_type: [`Doc] plugin; doc_custom: custom; doc_build: bool conditional; doc_install: bool conditional; doc_install_dir: unix_filename; doc_title: string; doc_authors: string list; doc_abstract: string option; doc_format: doc_format; doc_data_files: (unix_filename * unix_filename option) list; doc_build_tools: tool list; } type section = | Library of common_section * build_section * library | Object of common_section * build_section * object_ | Executable of common_section * build_section * executable | Flag of common_section * flag | SrcRepo of common_section * source_repository | Test of common_section * test | Doc of common_section * doc type section_kind = [ `Library | `Object | `Executable | `Flag | `SrcRepo | `Test | `Doc ] type package = { oasis_version: OASISVersion.t; ocaml_version: OASISVersion.comparator option; findlib_version: OASISVersion.comparator option; alpha_features: string list; beta_features: string list; name: package_name; version: OASISVersion.t; license: OASISLicense.t; license_file: unix_filename option; copyrights: string list; maintainers: string list; authors: string list; homepage: url option; synopsis: string; description: OASISText.t option; categories: url list; conf_type: [`Configure] plugin; conf_custom: custom; build_type: [`Build] plugin; build_custom: custom; install_type: [`Install] plugin; install_custom: custom; uninstall_custom: custom; clean_custom: custom; distclean_custom: custom; files_ab: unix_filename list; sections: section list; plugins: [`Extra] plugin list; disable_oasis_section: unix_filename list; schema_data: PropList.Data.t; plugin_data: plugin_data; } end module OASISFeatures = struct (* # 22 "src/oasis/OASISFeatures.ml" *) open OASISTypes open OASISUtils open OASISGettext open OASISVersion module MapPlugin = Map.Make (struct type t = plugin_kind * name let compare = Pervasives.compare end) module Data = struct type t = { oasis_version: OASISVersion.t; plugin_versions: OASISVersion.t option MapPlugin.t; alpha_features: string list; beta_features: string list; } let create oasis_version alpha_features beta_features = { oasis_version = oasis_version; plugin_versions = MapPlugin.empty; alpha_features = alpha_features; beta_features = beta_features } let of_package pkg = create pkg.OASISTypes.oasis_version pkg.OASISTypes.alpha_features pkg.OASISTypes.beta_features let add_plugin (plugin_kind, plugin_name, plugin_version) t = {t with plugin_versions = MapPlugin.add (plugin_kind, plugin_name) plugin_version t.plugin_versions} let plugin_version plugin_kind plugin_name t = MapPlugin.find (plugin_kind, plugin_name) t.plugin_versions let to_string t = Printf.sprintf "oasis_version: %s; alpha_features: %s; beta_features: %s; \ plugins_version: %s" (OASISVersion.string_of_version t.oasis_version) (String.concat ", " t.alpha_features) (String.concat ", " t.beta_features) (String.concat ", " (MapPlugin.fold (fun (_, plg) ver_opt acc -> (plg^ (match ver_opt with | Some v -> " "^(OASISVersion.string_of_version v) | None -> "")) :: acc) t.plugin_versions [])) end type origin = | Field of string * string | Section of string | NoOrigin type stage = Alpha | Beta let string_of_stage = function | Alpha -> "alpha" | Beta -> "beta" let field_of_stage = function | Alpha -> "AlphaFeatures" | Beta -> "BetaFeatures" type publication = InDev of stage | SinceVersion of OASISVersion.t type t = { name: string; plugin: all_plugin option; publication: publication; description: unit -> string; } (* TODO: mutex protect this. *) let all_features = Hashtbl.create 13 let since_version ver_str = SinceVersion (version_of_string ver_str) let alpha = InDev Alpha let beta = InDev Beta let to_string t = Printf.sprintf "feature: %s; plugin: %s; publication: %s" t.name (match t.plugin with | None -> "" | Some (_, nm, _) -> nm) (match t.publication with | InDev stage -> string_of_stage stage | SinceVersion ver -> ">= "^(OASISVersion.string_of_version ver)) let data_check t data origin = let no_message = "no message" in let check_feature features stage = let has_feature = List.mem t.name features in if not has_feature then match origin with | Field (fld, where) -> Some (Printf.sprintf (f_ "Field %s in %s is only available when feature %s \ is in field %s.") fld where t.name (field_of_stage stage)) | Section sct -> Some (Printf.sprintf (f_ "Section %s is only available when features %s \ is in field %s.") sct t.name (field_of_stage stage)) | NoOrigin -> Some no_message else None in let version_is_good ~min_version version fmt = let version_is_good = OASISVersion.comparator_apply version (OASISVersion.VGreaterEqual min_version) in Printf.ksprintf (fun str -> if version_is_good then None else Some str) fmt in match origin, t.plugin, t.publication with | _, _, InDev Alpha -> check_feature data.Data.alpha_features Alpha | _, _, InDev Beta -> check_feature data.Data.beta_features Beta | Field(fld, where), None, SinceVersion min_version -> version_is_good ~min_version data.Data.oasis_version (f_ "Field %s in %s is only valid since OASIS v%s, update \ OASISFormat field from '%s' to '%s' after checking \ OASIS changelog.") fld where (string_of_version min_version) (string_of_version data.Data.oasis_version) (string_of_version min_version) | Field(fld, where), Some(plugin_knd, plugin_name, _), SinceVersion min_version -> begin try let plugin_version_current = try match Data.plugin_version plugin_knd plugin_name data with | Some ver -> ver | None -> failwithf (f_ "Field %s in %s is only valid for the OASIS \ plugin %s since v%s, but no plugin version is \ defined in the _oasis file, change '%s' to \ '%s (%s)' in your _oasis file.") fld where plugin_name (string_of_version min_version) plugin_name plugin_name (string_of_version min_version) with Not_found -> failwithf (f_ "Field %s in %s is only valid when the OASIS plugin %s \ is defined.") fld where plugin_name in version_is_good ~min_version plugin_version_current (f_ "Field %s in %s is only valid for the OASIS plugin %s \ since v%s, update your plugin from '%s (%s)' to \ '%s (%s)' after checking the plugin's changelog.") fld where plugin_name (string_of_version min_version) plugin_name (string_of_version plugin_version_current) plugin_name (string_of_version min_version) with Failure msg -> Some msg end | Section sct, None, SinceVersion min_version -> version_is_good ~min_version data.Data.oasis_version (f_ "Section %s is only valid for since OASIS v%s, update \ OASISFormat field from '%s' to '%s' after checking OASIS \ changelog.") sct (string_of_version min_version) (string_of_version data.Data.oasis_version) (string_of_version min_version) | Section sct, Some(plugin_knd, plugin_name, _), SinceVersion min_version -> begin try let plugin_version_current = try match Data.plugin_version plugin_knd plugin_name data with | Some ver -> ver | None -> failwithf (f_ "Section %s is only valid for the OASIS \ plugin %s since v%s, but no plugin version is \ defined in the _oasis file, change '%s' to \ '%s (%s)' in your _oasis file.") sct plugin_name (string_of_version min_version) plugin_name plugin_name (string_of_version min_version) with Not_found -> failwithf (f_ "Section %s is only valid when the OASIS plugin %s \ is defined.") sct plugin_name in version_is_good ~min_version plugin_version_current (f_ "Section %s is only valid for the OASIS plugin %s \ since v%s, update your plugin from '%s (%s)' to \ '%s (%s)' after checking the plugin's changelog.") sct plugin_name (string_of_version min_version) plugin_name (string_of_version plugin_version_current) plugin_name (string_of_version min_version) with Failure msg -> Some msg end | NoOrigin, None, SinceVersion min_version -> version_is_good ~min_version data.Data.oasis_version "%s" no_message | NoOrigin, Some(plugin_knd, plugin_name, _), SinceVersion min_version -> begin try let plugin_version_current = match Data.plugin_version plugin_knd plugin_name data with | Some ver -> ver | None -> raise Not_found in version_is_good ~min_version plugin_version_current "%s" no_message with Not_found -> Some no_message end let data_assert t data origin = match data_check t data origin with | None -> () | Some str -> failwith str let data_test t data = match data_check t data NoOrigin with | None -> true | Some str -> false let package_test t pkg = data_test t (Data.of_package pkg) let create ?plugin name publication description = let () = if Hashtbl.mem all_features name then failwithf "Feature '%s' is already declared." name in let t = { name = name; plugin = plugin; publication = publication; description = description; } in Hashtbl.add all_features name t; t let get_stage name = try (Hashtbl.find all_features name).publication with Not_found -> failwithf (f_ "Feature %s doesn't exist.") name let list () = Hashtbl.fold (fun _ v acc -> v :: acc) all_features [] (* * Real flags. *) let features = create "features_fields" (since_version "0.4") (fun () -> s_ "Enable to experiment not yet official features.") let flag_docs = create "flag_docs" (since_version "0.3") (fun () -> s_ "Building docs require '-docs' flag at configure.") let flag_tests = create "flag_tests" (since_version "0.3") (fun () -> s_ "Running tests require '-tests' flag at configure.") let pack = create "pack" (since_version "0.3") (fun () -> s_ "Allow to create packed library.") let section_object = create "section_object" beta (fun () -> s_ "Implement an object section.") let dynrun_for_release = create "dynrun_for_release" alpha (fun () -> s_ "Make '-setup-update dynamic' suitable for releasing project.") let compiled_setup_ml = create "compiled_setup_ml" alpha (fun () -> s_ "It compiles the setup.ml and speed-up actions done with it.") let disable_oasis_section = create "disable_oasis_section" alpha (fun () -> s_ "Allows the OASIS section comments and digest to be omitted in \ generated files.") let no_automatic_syntax = create "no_automatic_syntax" alpha (fun () -> s_ "Disable the automatic inclusion of -syntax camlp4o for packages \ that matches the internal heuristic (if a dependency ends with \ a .syntax or is a well known syntax).") end module OASISUnixPath = struct (* # 22 "src/oasis/OASISUnixPath.ml" *) type unix_filename = string type unix_dirname = string type host_filename = string type host_dirname = string let current_dir_name = "." let parent_dir_name = ".." let is_current_dir fn = fn = current_dir_name || fn = "" let concat f1 f2 = if is_current_dir f1 then f2 else let f1' = try OASISString.strip_ends_with ~what:"/" f1 with Not_found -> f1 in f1'^"/"^f2 let make = function | hd :: tl -> List.fold_left (fun f p -> concat f p) hd tl | [] -> invalid_arg "OASISUnixPath.make" let dirname f = try String.sub f 0 (String.rindex f '/') with Not_found -> current_dir_name let basename f = try let pos_start = (String.rindex f '/') + 1 in String.sub f pos_start ((String.length f) - pos_start) with Not_found -> f let chop_extension f = try let last_dot = String.rindex f '.' in let sub = String.sub f 0 last_dot in try let last_slash = String.rindex f '/' in if last_slash < last_dot then sub else f with Not_found -> sub with Not_found -> f let capitalize_file f = let dir = dirname f in let base = basename f in concat dir (String.capitalize base) let uncapitalize_file f = let dir = dirname f in let base = basename f in concat dir (String.uncapitalize base) end module OASISHostPath = struct (* # 22 "src/oasis/OASISHostPath.ml" *) open Filename module Unix = OASISUnixPath let make = function | [] -> invalid_arg "OASISHostPath.make" | hd :: tl -> List.fold_left Filename.concat hd tl let of_unix ufn = if Sys.os_type = "Unix" then ufn else make (List.map (fun p -> if p = Unix.current_dir_name then current_dir_name else if p = Unix.parent_dir_name then parent_dir_name else p) (OASISString.nsplit ufn '/')) end module OASISSection = struct (* # 22 "src/oasis/OASISSection.ml" *) open OASISTypes let section_kind_common = function | Library (cs, _, _) -> `Library, cs | Object (cs, _, _) -> `Object, cs | Executable (cs, _, _) -> `Executable, cs | Flag (cs, _) -> `Flag, cs | SrcRepo (cs, _) -> `SrcRepo, cs | Test (cs, _) -> `Test, cs | Doc (cs, _) -> `Doc, cs let section_common sct = snd (section_kind_common sct) let section_common_set cs = function | Library (_, bs, lib) -> Library (cs, bs, lib) | Object (_, bs, obj) -> Object (cs, bs, obj) | Executable (_, bs, exec) -> Executable (cs, bs, exec) | Flag (_, flg) -> Flag (cs, flg) | SrcRepo (_, src_repo) -> SrcRepo (cs, src_repo) | Test (_, tst) -> Test (cs, tst) | Doc (_, doc) -> Doc (cs, doc) (** Key used to identify section *) let section_id sct = let k, cs = section_kind_common sct in k, cs.cs_name let string_of_section sct = let k, nm = section_id sct in (match k with | `Library -> "library" | `Object -> "object" | `Executable -> "executable" | `Flag -> "flag" | `SrcRepo -> "src repository" | `Test -> "test" | `Doc -> "doc") ^" "^nm let section_find id scts = List.find (fun sct -> id = section_id sct) scts module CSection = struct type t = section let id = section_id let compare t1 t2 = compare (id t1) (id t2) let equal t1 t2 = (id t1) = (id t2) let hash t = Hashtbl.hash (id t) end module MapSection = Map.Make(CSection) module SetSection = Set.Make(CSection) end module OASISBuildSection = struct (* # 22 "src/oasis/OASISBuildSection.ml" *) end module OASISExecutable = struct (* # 22 "src/oasis/OASISExecutable.ml" *) open OASISTypes let unix_exec_is (cs, bs, exec) is_native ext_dll suffix_program = let dir = OASISUnixPath.concat bs.bs_path (OASISUnixPath.dirname exec.exec_main_is) in let is_native_exec = match bs.bs_compiled_object with | Native -> true | Best -> is_native () | Byte -> false in OASISUnixPath.concat dir (cs.cs_name^(suffix_program ())), if not is_native_exec && not exec.exec_custom && bs.bs_c_sources <> [] then Some (dir^"/dll"^cs.cs_name^"_stubs"^(ext_dll ())) else None end module OASISLibrary = struct (* # 22 "src/oasis/OASISLibrary.ml" *) open OASISTypes open OASISUtils open OASISGettext open OASISSection (* Look for a module file, considering capitalization or not. *) let find_module source_file_exists bs modul = let possible_base_fn = List.map (OASISUnixPath.concat bs.bs_path) [modul; OASISUnixPath.uncapitalize_file modul; OASISUnixPath.capitalize_file modul] in (* TODO: we should be able to be able to determine the source for every * files. Hence we should introduce a Module(source: fn) for the fields * Modules and InternalModules *) List.fold_left (fun acc base_fn -> match acc with | `No_sources _ -> begin let file_found = List.fold_left (fun acc ext -> if source_file_exists (base_fn^ext) then (base_fn^ext) :: acc else acc) [] [".ml"; ".mli"; ".mll"; ".mly"] in match file_found with | [] -> acc | lst -> `Sources (base_fn, lst) end | `Sources _ -> acc) (`No_sources possible_base_fn) possible_base_fn let source_unix_files ~ctxt (cs, bs, lib) source_file_exists = List.fold_left (fun acc modul -> match find_module source_file_exists bs modul with | `Sources (base_fn, lst) -> (base_fn, lst) :: acc | `No_sources _ -> OASISMessage.warning ~ctxt (f_ "Cannot find source file matching \ module '%s' in library %s") modul cs.cs_name; acc) [] (lib.lib_modules @ lib.lib_internal_modules) let generated_unix_files ~ctxt ~is_native ~has_native_dynlink ~ext_lib ~ext_dll ~source_file_exists (cs, bs, lib) = let find_modules lst ext = let find_module modul = match find_module source_file_exists bs modul with | `Sources (base_fn, [fn]) when ext <> "cmi" && Filename.check_suffix fn ".mli" -> None (* No implementation files for pure interface. *) | `Sources (base_fn, _) -> Some [base_fn] | `No_sources lst -> OASISMessage.warning ~ctxt (f_ "Cannot find source file matching \ module '%s' in library %s") modul cs.cs_name; Some lst in List.fold_left (fun acc nm -> match find_module nm with | None -> acc | Some base_fns -> List.map (fun base_fn -> base_fn ^"."^ext) base_fns :: acc) [] lst in (* The .cmx that be compiled along *) let cmxs = let should_be_built = match bs.bs_compiled_object with | Native -> true | Best -> is_native | Byte -> false in if should_be_built then if lib.lib_pack then find_modules [cs.cs_name] "cmx" else find_modules (lib.lib_modules @ lib.lib_internal_modules) "cmx" else [] in let acc_nopath = [] in (* The headers and annot/cmt files that should be compiled along *) let headers = let sufx = if lib.lib_pack then [".cmti"; ".cmt"; ".annot"] else [".cmi"; ".cmti"; ".cmt"; ".annot"] in List.map begin List.fold_left begin fun accu s -> let dot = String.rindex s '.' in let base = String.sub s 0 dot in List.map ((^) base) sufx @ accu end [] end (find_modules lib.lib_modules "cmi") in (* Compute what libraries should be built *) let acc_nopath = (* Add the packed header file if required *) let add_pack_header acc = if lib.lib_pack then [cs.cs_name^".cmi"; cs.cs_name^".cmti"; cs.cs_name^".cmt"] :: acc else acc in let byte acc = add_pack_header ([cs.cs_name^".cma"] :: acc) in let native acc = let acc = add_pack_header (if has_native_dynlink then [cs.cs_name^".cmxs"] :: acc else acc) in [cs.cs_name^".cmxa"] :: [cs.cs_name^ext_lib] :: acc in match bs.bs_compiled_object with | Native -> byte (native acc_nopath) | Best when is_native -> byte (native acc_nopath) | Byte | Best -> byte acc_nopath in (* Add C library to be built *) let acc_nopath = if bs.bs_c_sources <> [] then begin ["lib"^cs.cs_name^"_stubs"^ext_lib] :: ["dll"^cs.cs_name^"_stubs"^ext_dll] :: acc_nopath end else acc_nopath in (* All the files generated *) List.rev_append (List.rev_map (List.rev_map (OASISUnixPath.concat bs.bs_path)) acc_nopath) (headers @ cmxs) end module OASISObject = struct (* # 22 "src/oasis/OASISObject.ml" *) open OASISTypes open OASISGettext let source_unix_files ~ctxt (cs, bs, obj) source_file_exists = List.fold_left (fun acc modul -> match OASISLibrary.find_module source_file_exists bs modul with | `Sources (base_fn, lst) -> (base_fn, lst) :: acc | `No_sources _ -> OASISMessage.warning ~ctxt (f_ "Cannot find source file matching \ module '%s' in object %s") modul cs.cs_name; acc) [] obj.obj_modules let generated_unix_files ~ctxt ~is_native ~source_file_exists (cs, bs, obj) = let find_module ext modul = match OASISLibrary.find_module source_file_exists bs modul with | `Sources (base_fn, _) -> [base_fn ^ ext] | `No_sources lst -> OASISMessage.warning ~ctxt (f_ "Cannot find source file matching \ module '%s' in object %s") modul cs.cs_name ; lst in let header, byte, native, c_object, f = match obj.obj_modules with | [ m ] -> (find_module ".cmi" m, find_module ".cmo" m, find_module ".cmx" m, find_module ".o" m, fun x -> x) | _ -> ([cs.cs_name ^ ".cmi"], [cs.cs_name ^ ".cmo"], [cs.cs_name ^ ".cmx"], [cs.cs_name ^ ".o"], OASISUnixPath.concat bs.bs_path) in List.map (List.map f) ( match bs.bs_compiled_object with | Native -> native :: c_object :: byte :: header :: [] | Best when is_native -> native :: c_object :: byte :: header :: [] | Byte | Best -> byte :: header :: []) end module OASISFindlib = struct (* # 22 "src/oasis/OASISFindlib.ml" *) open OASISTypes open OASISUtils open OASISGettext open OASISSection type library_name = name type findlib_part_name = name type 'a map_of_findlib_part_name = 'a OASISUtils.MapString.t exception InternalLibraryNotFound of library_name exception FindlibPackageNotFound of findlib_name type group_t = | Container of findlib_name * group_t list | Package of (findlib_name * common_section * build_section * [`Library of library | `Object of object_] * group_t list) type data = common_section * build_section * [`Library of library | `Object of object_] type tree = | Node of (data option) * (tree MapString.t) | Leaf of data let findlib_mapping pkg = (* Map from library name to either full findlib name or parts + parent. *) let fndlb_parts_of_lib_name = let fndlb_parts cs lib = let name = match lib.lib_findlib_name with | Some nm -> nm | None -> cs.cs_name in let name = String.concat "." (lib.lib_findlib_containers @ [name]) in name in List.fold_left (fun mp -> function | Library (cs, _, lib) -> begin let lib_name = cs.cs_name in let fndlb_parts = fndlb_parts cs lib in if MapString.mem lib_name mp then failwithf (f_ "The library name '%s' is used more than once.") lib_name; match lib.lib_findlib_parent with | Some lib_name_parent -> MapString.add lib_name (`Unsolved (lib_name_parent, fndlb_parts)) mp | None -> MapString.add lib_name (`Solved fndlb_parts) mp end | Object (cs, _, obj) -> begin let obj_name = cs.cs_name in if MapString.mem obj_name mp then failwithf (f_ "The object name '%s' is used more than once.") obj_name; let findlib_full_name = match obj.obj_findlib_fullname with | Some ns -> String.concat "." ns | None -> obj_name in MapString.add obj_name (`Solved findlib_full_name) mp end | Executable _ | Test _ | Flag _ | SrcRepo _ | Doc _ -> mp) MapString.empty pkg.sections in (* Solve the above graph to be only library name to full findlib name. *) let fndlb_name_of_lib_name = let rec solve visited mp lib_name lib_name_child = if SetString.mem lib_name visited then failwithf (f_ "Library '%s' is involved in a cycle \ with regard to findlib naming.") lib_name; let visited = SetString.add lib_name visited in try match MapString.find lib_name mp with | `Solved fndlb_nm -> fndlb_nm, mp | `Unsolved (lib_nm_parent, post_fndlb_nm) -> let pre_fndlb_nm, mp = solve visited mp lib_nm_parent lib_name in let fndlb_nm = pre_fndlb_nm^"."^post_fndlb_nm in fndlb_nm, MapString.add lib_name (`Solved fndlb_nm) mp with Not_found -> failwithf (f_ "Library '%s', which is defined as the findlib parent of \ library '%s', doesn't exist.") lib_name lib_name_child in let mp = MapString.fold (fun lib_name status mp -> match status with | `Solved _ -> (* Solved initialy, no need to go further *) mp | `Unsolved _ -> let _, mp = solve SetString.empty mp lib_name "" in mp) fndlb_parts_of_lib_name fndlb_parts_of_lib_name in MapString.map (function | `Solved fndlb_nm -> fndlb_nm | `Unsolved _ -> assert false) mp in (* Convert an internal library name to a findlib name. *) let findlib_name_of_library_name lib_nm = try MapString.find lib_nm fndlb_name_of_lib_name with Not_found -> raise (InternalLibraryNotFound lib_nm) in (* Add a library to the tree. *) let add sct mp = let fndlb_fullname = let cs, _, _ = sct in let lib_name = cs.cs_name in findlib_name_of_library_name lib_name in let rec add_children nm_lst (children: tree MapString.t) = match nm_lst with | (hd :: tl) -> begin let node = try add_node tl (MapString.find hd children) with Not_found -> (* New node *) new_node tl in MapString.add hd node children end | [] -> (* Should not have a nameless library. *) assert false and add_node tl node = if tl = [] then begin match node with | Node (None, children) -> Node (Some sct, children) | Leaf (cs', _, _) | Node (Some (cs', _, _), _) -> (* TODO: allow to merge Package, i.e. * archive(byte) = "foo.cma foo_init.cmo" *) let cs, _, _ = sct in failwithf (f_ "Library '%s' and '%s' have the same findlib name '%s'") cs.cs_name cs'.cs_name fndlb_fullname end else begin match node with | Leaf data -> Node (Some data, add_children tl MapString.empty) | Node (data_opt, children) -> Node (data_opt, add_children tl children) end and new_node = function | [] -> Leaf sct | hd :: tl -> Node (None, MapString.add hd (new_node tl) MapString.empty) in add_children (OASISString.nsplit fndlb_fullname '.') mp in let rec group_of_tree mp = MapString.fold (fun nm node acc -> let cur = match node with | Node (Some (cs, bs, lib), children) -> Package (nm, cs, bs, lib, group_of_tree children) | Node (None, children) -> Container (nm, group_of_tree children) | Leaf (cs, bs, lib) -> Package (nm, cs, bs, lib, []) in cur :: acc) mp [] in let group_mp = List.fold_left (fun mp -> function | Library (cs, bs, lib) -> add (cs, bs, `Library lib) mp | Object (cs, bs, obj) -> add (cs, bs, `Object obj) mp | _ -> mp) MapString.empty pkg.sections in let groups = group_of_tree group_mp in let library_name_of_findlib_name = lazy begin (* Revert findlib_name_of_library_name. *) MapString.fold (fun k v mp -> MapString.add v k mp) fndlb_name_of_lib_name MapString.empty end in let library_name_of_findlib_name fndlb_nm = try MapString.find fndlb_nm (Lazy.force library_name_of_findlib_name) with Not_found -> raise (FindlibPackageNotFound fndlb_nm) in groups, findlib_name_of_library_name, library_name_of_findlib_name let findlib_of_group = function | Container (fndlb_nm, _) | Package (fndlb_nm, _, _, _, _) -> fndlb_nm let root_of_group grp = let rec root_lib_aux = (* We do a DFS in the group. *) function | Container (_, children) -> List.fold_left (fun res grp -> if res = None then root_lib_aux grp else res) None children | Package (_, cs, bs, lib, _) -> Some (cs, bs, lib) in match root_lib_aux grp with | Some res -> res | None -> failwithf (f_ "Unable to determine root library of findlib library '%s'") (findlib_of_group grp) end module OASISFlag = struct (* # 22 "src/oasis/OASISFlag.ml" *) end module OASISPackage = struct (* # 22 "src/oasis/OASISPackage.ml" *) end module OASISSourceRepository = struct (* # 22 "src/oasis/OASISSourceRepository.ml" *) end module OASISTest = struct (* # 22 "src/oasis/OASISTest.ml" *) end module OASISDocument = struct (* # 22 "src/oasis/OASISDocument.ml" *) end module OASISExec = struct (* # 22 "src/oasis/OASISExec.ml" *) open OASISGettext open OASISUtils open OASISMessage (* TODO: I don't like this quote, it is there because $(rm) foo expands to * 'rm -f' foo... *) let run ~ctxt ?f_exit_code ?(quote=true) cmd args = let cmd = if quote then if Sys.os_type = "Win32" then if String.contains cmd ' ' then (* Double the 1st double quote... win32... sigh *) "\""^(Filename.quote cmd) else cmd else Filename.quote cmd else cmd in let cmdline = String.concat " " (cmd :: args) in info ~ctxt (f_ "Running command '%s'") cmdline; match f_exit_code, Sys.command cmdline with | None, 0 -> () | None, i -> failwithf (f_ "Command '%s' terminated with error code %d") cmdline i | Some f, i -> f i let run_read_output ~ctxt ?f_exit_code cmd args = let fn = Filename.temp_file "oasis-" ".txt" in try begin let () = run ~ctxt ?f_exit_code cmd (args @ [">"; Filename.quote fn]) in let chn = open_in fn in let routput = ref [] in begin try while true do routput := (input_line chn) :: !routput done with End_of_file -> () end; close_in chn; Sys.remove fn; List.rev !routput end with e -> (try Sys.remove fn with _ -> ()); raise e let run_read_one_line ~ctxt ?f_exit_code cmd args = match run_read_output ~ctxt ?f_exit_code cmd args with | [fst] -> fst | lst -> failwithf (f_ "Command return unexpected output %S") (String.concat "\n" lst) end module OASISFileUtil = struct (* # 22 "src/oasis/OASISFileUtil.ml" *) open OASISGettext let file_exists_case fn = let dirname = Filename.dirname fn in let basename = Filename.basename fn in if Sys.file_exists dirname then if basename = Filename.current_dir_name then true else List.mem basename (Array.to_list (Sys.readdir dirname)) else false let find_file ?(case_sensitive=true) paths exts = (* Cardinal product of two list *) let ( * ) lst1 lst2 = List.flatten (List.map (fun a -> List.map (fun b -> a, b) lst2) lst1) in let rec combined_paths lst = match lst with | p1 :: p2 :: tl -> let acc = (List.map (fun (a, b) -> Filename.concat a b) (p1 * p2)) in combined_paths (acc :: tl) | [e] -> e | [] -> [] in let alternatives = List.map (fun (p, e) -> if String.length e > 0 && e.[0] <> '.' then p ^ "." ^ e else p ^ e) ((combined_paths paths) * exts) in List.find (fun file -> (if case_sensitive then file_exists_case file else Sys.file_exists file) && not (Sys.is_directory file) ) alternatives let which ~ctxt prg = let path_sep = match Sys.os_type with | "Win32" -> ';' | _ -> ':' in let path_lst = OASISString.nsplit (Sys.getenv "PATH") path_sep in let exec_ext = match Sys.os_type with | "Win32" -> "" :: (OASISString.nsplit (Sys.getenv "PATHEXT") path_sep) | _ -> [""] in find_file ~case_sensitive:false [path_lst; [prg]] exec_ext (**/**) let rec fix_dir dn = (* Windows hack because Sys.file_exists "src\\" = false when * Sys.file_exists "src" = true *) let ln = String.length dn in if Sys.os_type = "Win32" && ln > 0 && dn.[ln - 1] = '\\' then fix_dir (String.sub dn 0 (ln - 1)) else dn let q = Filename.quote (**/**) let cp ~ctxt ?(recurse=false) src tgt = if recurse then match Sys.os_type with | "Win32" -> OASISExec.run ~ctxt "xcopy" [q src; q tgt; "/E"] | _ -> OASISExec.run ~ctxt "cp" ["-r"; q src; q tgt] else OASISExec.run ~ctxt (match Sys.os_type with | "Win32" -> "copy" | _ -> "cp") [q src; q tgt] let mkdir ~ctxt tgt = OASISExec.run ~ctxt (match Sys.os_type with | "Win32" -> "md" | _ -> "mkdir") [q tgt] let rec mkdir_parent ~ctxt f tgt = let tgt = fix_dir tgt in if Sys.file_exists tgt then begin if not (Sys.is_directory tgt) then OASISUtils.failwithf (f_ "Cannot create directory '%s', a file of the same name already \ exists") tgt end else begin mkdir_parent ~ctxt f (Filename.dirname tgt); if not (Sys.file_exists tgt) then begin f tgt; mkdir ~ctxt tgt end end let rmdir ~ctxt tgt = if Sys.readdir tgt = [||] then begin match Sys.os_type with | "Win32" -> OASISExec.run ~ctxt "rd" [q tgt] | _ -> OASISExec.run ~ctxt "rm" ["-r"; q tgt] end else begin OASISMessage.error ~ctxt (f_ "Cannot remove directory '%s': not empty.") tgt end let glob ~ctxt fn = let basename = Filename.basename fn in if String.length basename >= 2 && basename.[0] = '*' && basename.[1] = '.' then begin let ext_len = (String.length basename) - 2 in let ext = String.sub basename 2 ext_len in let dirname = Filename.dirname fn in Array.fold_left (fun acc fn -> try let fn_ext = String.sub fn ((String.length fn) - ext_len) ext_len in if fn_ext = ext then (Filename.concat dirname fn) :: acc else acc with Invalid_argument _ -> acc) [] (Sys.readdir dirname) end else begin if file_exists_case fn then [fn] else [] end end # 2893 "setup.ml" module BaseEnvLight = struct (* # 22 "src/base/BaseEnvLight.ml" *) module MapString = Map.Make(String) type t = string MapString.t let default_filename = Filename.concat (Sys.getcwd ()) "setup.data" let load ?(allow_empty=false) ?(filename=default_filename) () = if Sys.file_exists filename then begin let chn = open_in_bin filename in let st = Stream.of_channel chn in let line = ref 1 in let st_line = Stream.from (fun _ -> try match Stream.next st with | '\n' -> incr line; Some '\n' | c -> Some c with Stream.Failure -> None) in let lexer = Genlex.make_lexer ["="] st_line in let rec read_file mp = match Stream.npeek 3 lexer with | [Genlex.Ident nm; Genlex.Kwd "="; Genlex.String value] -> Stream.junk lexer; Stream.junk lexer; Stream.junk lexer; read_file (MapString.add nm value mp) | [] -> mp | _ -> failwith (Printf.sprintf "Malformed data file '%s' line %d" filename !line) in let mp = read_file MapString.empty in close_in chn; mp end else if allow_empty then begin MapString.empty end else begin failwith (Printf.sprintf "Unable to load environment, the file '%s' doesn't exist." filename) end let rec var_expand str env = let buff = Buffer.create ((String.length str) * 2) in Buffer.add_substitute buff (fun var -> try var_expand (MapString.find var env) env with Not_found -> failwith (Printf.sprintf "No variable %s defined when trying to expand %S." var str)) str; Buffer.contents buff let var_get name env = var_expand (MapString.find name env) env let var_choose lst env = OASISExpr.choose (fun nm -> var_get nm env) lst end # 2998 "setup.ml" module BaseContext = struct (* # 22 "src/base/BaseContext.ml" *) (* TODO: get rid of this module. *) open OASISContext let args () = fst (fspecs ()) let default = default end module BaseMessage = struct (* # 22 "src/base/BaseMessage.ml" *) (** Message to user, overrid for Base @author Sylvain Le Gall *) open OASISMessage open BaseContext let debug fmt = debug ~ctxt:!default fmt let info fmt = info ~ctxt:!default fmt let warning fmt = warning ~ctxt:!default fmt let error fmt = error ~ctxt:!default fmt end module BaseEnv = struct (* # 22 "src/base/BaseEnv.ml" *) open OASISGettext open OASISUtils open PropList module MapString = BaseEnvLight.MapString type origin_t = | ODefault | OGetEnv | OFileLoad | OCommandLine type cli_handle_t = | CLINone | CLIAuto | CLIWith | CLIEnable | CLIUser of (Arg.key * Arg.spec * Arg.doc) list type definition_t = { hide: bool; dump: bool; cli: cli_handle_t; arg_help: string option; group: string option; } let schema = Schema.create "environment" (* Environment data *) let env = Data.create () (* Environment data from file *) let env_from_file = ref MapString.empty (* Lexer for var *) let var_lxr = Genlex.make_lexer [] let rec var_expand str = let buff = Buffer.create ((String.length str) * 2) in Buffer.add_substitute buff (fun var -> try (* TODO: this is a quick hack to allow calling Test.Command * without defining executable name really. I.e. if there is * an exec Executable toto, then $(toto) should be replace * by its real name. It is however useful to have this function * for other variable that depend on the host and should be * written better than that. *) let st = var_lxr (Stream.of_string var) in match Stream.npeek 3 st with | [Genlex.Ident "utoh"; Genlex.Ident nm] -> OASISHostPath.of_unix (var_get nm) | [Genlex.Ident "utoh"; Genlex.String s] -> OASISHostPath.of_unix s | [Genlex.Ident "ocaml_escaped"; Genlex.Ident nm] -> String.escaped (var_get nm) | [Genlex.Ident "ocaml_escaped"; Genlex.String s] -> String.escaped s | [Genlex.Ident nm] -> var_get nm | _ -> failwithf (f_ "Unknown expression '%s' in variable expansion of %s.") var str with | Unknown_field (_, _) -> failwithf (f_ "No variable %s defined when trying to expand %S.") var str | Stream.Error e -> failwithf (f_ "Syntax error when parsing '%s' when trying to \ expand %S: %s") var str e) str; Buffer.contents buff and var_get name = let vl = try Schema.get schema env name with Unknown_field _ as e -> begin try MapString.find name !env_from_file with Not_found -> raise e end in var_expand vl let var_choose ?printer ?name lst = OASISExpr.choose ?printer ?name var_get lst let var_protect vl = let buff = Buffer.create (String.length vl) in String.iter (function | '$' -> Buffer.add_string buff "\\$" | c -> Buffer.add_char buff c) vl; Buffer.contents buff let var_define ?(hide=false) ?(dump=true) ?short_desc ?(cli=CLINone) ?arg_help ?group name (* TODO: type constraint on the fact that name must be a valid OCaml id *) dflt = let default = [ OFileLoad, (fun () -> MapString.find name !env_from_file); ODefault, dflt; OGetEnv, (fun () -> Sys.getenv name); ] in let extra = { hide = hide; dump = dump; cli = cli; arg_help = arg_help; group = group; } in (* Try to find a value that can be defined *) let var_get_low lst = let errors, res = List.fold_left (fun (errors, res) (o, v) -> if res = None then begin try errors, Some (v ()) with | Not_found -> errors, res | Failure rsn -> (rsn :: errors), res | e -> (Printexc.to_string e) :: errors, res end else errors, res) ([], None) (List.sort (fun (o1, _) (o2, _) -> Pervasives.compare o2 o1) lst) in match res, errors with | Some v, _ -> v | None, [] -> raise (Not_set (name, None)) | None, lst -> raise (Not_set (name, Some (String.concat (s_ ", ") lst))) in let help = match short_desc with | Some fs -> Some fs | None -> None in let var_get_lst = FieldRO.create ~schema ~name ~parse:(fun ?(context=ODefault) s -> [context, fun () -> s]) ~print:var_get_low ~default ~update:(fun ?context x old_x -> x @ old_x) ?help extra in fun () -> var_expand (var_get_low (var_get_lst env)) let var_redefine ?hide ?dump ?short_desc ?cli ?arg_help ?group name dflt = if Schema.mem schema name then begin (* TODO: look suspsicious, we want to memorize dflt not dflt () *) Schema.set schema env ~context:ODefault name (dflt ()); fun () -> var_get name end else begin var_define ?hide ?dump ?short_desc ?cli ?arg_help ?group name dflt end let var_ignore (e: unit -> string) = () let print_hidden = var_define ~hide:true ~dump:false ~cli:CLIAuto ~arg_help:"Print even non-printable variable. (debug)" "print_hidden" (fun () -> "false") let var_all () = List.rev (Schema.fold (fun acc nm def _ -> if not def.hide || bool_of_string (print_hidden ()) then nm :: acc else acc) [] schema) let default_filename = BaseEnvLight.default_filename let load ?allow_empty ?filename () = env_from_file := BaseEnvLight.load ?allow_empty ?filename () let unload () = env_from_file := MapString.empty; Data.clear env let dump ?(filename=default_filename) () = let chn = open_out_bin filename in let output nm value = Printf.fprintf chn "%s=%S\n" nm value in let mp_todo = (* Dump data from schema *) Schema.fold (fun mp_todo nm def _ -> if def.dump then begin try let value = Schema.get schema env nm in output nm value with Not_set _ -> () end; MapString.remove nm mp_todo) !env_from_file schema in (* Dump data defined outside of schema *) MapString.iter output mp_todo; (* End of the dump *) close_out chn let print () = let printable_vars = Schema.fold (fun acc nm def short_descr_opt -> if not def.hide || bool_of_string (print_hidden ()) then begin try let value = Schema.get schema env nm in let txt = match short_descr_opt with | Some s -> s () | None -> nm in (txt, value) :: acc with Not_set _ -> acc end else acc) [] schema in let max_length = List.fold_left max 0 (List.rev_map String.length (List.rev_map fst printable_vars)) in let dot_pad str = String.make ((max_length - (String.length str)) + 3) '.' in Printf.printf "\nConfiguration: \n"; List.iter (fun (name, value) -> Printf.printf "%s: %s %s\n" name (dot_pad name) value) (List.rev printable_vars); Printf.printf "\n%!" let args () = let arg_concat = OASISUtils.varname_concat ~hyphen:'-' in [ "--override", Arg.Tuple ( let rvr = ref "" in let rvl = ref "" in [ Arg.Set_string rvr; Arg.Set_string rvl; Arg.Unit (fun () -> Schema.set schema env ~context:OCommandLine !rvr !rvl) ] ), "var+val Override any configuration variable."; ] @ List.flatten (Schema.fold (fun acc name def short_descr_opt -> let var_set s = Schema.set schema env ~context:OCommandLine name s in let arg_name = OASISUtils.varname_of_string ~hyphen:'-' name in let hlp = match short_descr_opt with | Some txt -> txt () | None -> "" in let arg_hlp = match def.arg_help with | Some s -> s | None -> "str" in let default_value = try Printf.sprintf (f_ " [%s]") (Schema.get schema env name) with Not_set _ -> "" in let args = match def.cli with | CLINone -> [] | CLIAuto -> [ arg_concat "--" arg_name, Arg.String var_set, Printf.sprintf (f_ "%s %s%s") arg_hlp hlp default_value ] | CLIWith -> [ arg_concat "--with-" arg_name, Arg.String var_set, Printf.sprintf (f_ "%s %s%s") arg_hlp hlp default_value ] | CLIEnable -> let dflt = if default_value = " [true]" then s_ " [default: enabled]" else s_ " [default: disabled]" in [ arg_concat "--enable-" arg_name, Arg.Unit (fun () -> var_set "true"), Printf.sprintf (f_ " %s%s") hlp dflt; arg_concat "--disable-" arg_name, Arg.Unit (fun () -> var_set "false"), Printf.sprintf (f_ " %s%s") hlp dflt ] | CLIUser lst -> lst in args :: acc) [] schema) end module BaseArgExt = struct (* # 22 "src/base/BaseArgExt.ml" *) open OASISUtils open OASISGettext let parse argv args = (* Simulate command line for Arg *) let current = ref 0 in try Arg.parse_argv ~current:current (Array.concat [[|"none"|]; argv]) (Arg.align args) (failwithf (f_ "Don't know what to do with arguments: '%s'")) (s_ "configure options:") with | Arg.Help txt -> print_endline txt; exit 0 | Arg.Bad txt -> prerr_endline txt; exit 1 end module BaseCheck = struct (* # 22 "src/base/BaseCheck.ml" *) open BaseEnv open BaseMessage open OASISUtils open OASISGettext let prog_best prg prg_lst = var_redefine prg (fun () -> let alternate = List.fold_left (fun res e -> match res with | Some _ -> res | None -> try Some (OASISFileUtil.which ~ctxt:!BaseContext.default e) with Not_found -> None) None prg_lst in match alternate with | Some prg -> prg | None -> raise Not_found) let prog prg = prog_best prg [prg] let prog_opt prg = prog_best prg [prg^".opt"; prg] let ocamlfind = prog "ocamlfind" let version var_prefix cmp fversion () = (* Really compare version provided *) let var = var_prefix^"_version_"^(OASISVersion.varname_of_comparator cmp) in var_redefine ~hide:true var (fun () -> let version_str = match fversion () with | "[Distributed with OCaml]" -> begin try (var_get "ocaml_version") with Not_found -> warning (f_ "Variable ocaml_version not defined, fallback \ to default"); Sys.ocaml_version end | res -> res in let version = OASISVersion.version_of_string version_str in if OASISVersion.comparator_apply version cmp then version_str else failwithf (f_ "Cannot satisfy version constraint on %s: %s (version: %s)") var_prefix (OASISVersion.string_of_comparator cmp) version_str) () let package_version pkg = OASISExec.run_read_one_line ~ctxt:!BaseContext.default (ocamlfind ()) ["query"; "-format"; "%v"; pkg] let package ?version_comparator pkg () = let var = OASISUtils.varname_concat "pkg_" (OASISUtils.varname_of_string pkg) in let findlib_dir pkg = let dir = OASISExec.run_read_one_line ~ctxt:!BaseContext.default (ocamlfind ()) ["query"; "-format"; "%d"; pkg] in if Sys.file_exists dir && Sys.is_directory dir then dir else failwithf (f_ "When looking for findlib package %s, \ directory %s return doesn't exist") pkg dir in let vl = var_redefine var (fun () -> findlib_dir pkg) () in ( match version_comparator with | Some ver_cmp -> ignore (version var ver_cmp (fun _ -> package_version pkg) ()) | None -> () ); vl end module BaseOCamlcConfig = struct (* # 22 "src/base/BaseOCamlcConfig.ml" *) open BaseEnv open OASISUtils open OASISGettext module SMap = Map.Make(String) let ocamlc = BaseCheck.prog_opt "ocamlc" let ocamlc_config_map = (* Map name to value for ocamlc -config output (name ^": "^value) *) let rec split_field mp lst = match lst with | line :: tl -> let mp = try let pos_semicolon = String.index line ':' in if pos_semicolon > 1 then ( let name = String.sub line 0 pos_semicolon in let linelen = String.length line in let value = if linelen > pos_semicolon + 2 then String.sub line (pos_semicolon + 2) (linelen - pos_semicolon - 2) else "" in SMap.add name value mp ) else ( mp ) with Not_found -> ( mp ) in split_field mp tl | [] -> mp in let cache = lazy (var_protect (Marshal.to_string (split_field SMap.empty (OASISExec.run_read_output ~ctxt:!BaseContext.default (ocamlc ()) ["-config"])) [])) in var_redefine "ocamlc_config_map" ~hide:true ~dump:false (fun () -> (* TODO: update if ocamlc change !!! *) Lazy.force cache) let var_define nm = (* Extract data from ocamlc -config *) let avlbl_config_get () = Marshal.from_string (ocamlc_config_map ()) 0 in let chop_version_suffix s = try String.sub s 0 (String.index s '+') with _ -> s in let nm_config, value_config = match nm with | "ocaml_version" -> "version", chop_version_suffix | _ -> nm, (fun x -> x) in var_redefine nm (fun () -> try let map = avlbl_config_get () in let value = SMap.find nm_config map in value_config value with Not_found -> failwithf (f_ "Cannot find field '%s' in '%s -config' output") nm (ocamlc ())) end module BaseStandardVar = struct (* # 22 "src/base/BaseStandardVar.ml" *) open OASISGettext open OASISTypes open OASISExpr open BaseCheck open BaseEnv let ocamlfind = BaseCheck.ocamlfind let ocamlc = BaseOCamlcConfig.ocamlc let ocamlopt = prog_opt "ocamlopt" let ocamlbuild = prog "ocamlbuild" (**/**) let rpkg = ref None let pkg_get () = match !rpkg with | Some pkg -> pkg | None -> failwith (s_ "OASIS Package is not set") let var_cond = ref [] let var_define_cond ~since_version f dflt = let holder = ref (fun () -> dflt) in let since_version = OASISVersion.VGreaterEqual (OASISVersion.version_of_string since_version) in var_cond := (fun ver -> if OASISVersion.comparator_apply ver since_version then holder := f ()) :: !var_cond; fun () -> !holder () (**/**) let pkg_name = var_define ~short_desc:(fun () -> s_ "Package name") "pkg_name" (fun () -> (pkg_get ()).name) let pkg_version = var_define ~short_desc:(fun () -> s_ "Package version") "pkg_version" (fun () -> (OASISVersion.string_of_version (pkg_get ()).version)) let c = BaseOCamlcConfig.var_define let os_type = c "os_type" let system = c "system" let architecture = c "architecture" let ccomp_type = c "ccomp_type" let ocaml_version = c "ocaml_version" (* TODO: Check standard variable presence at runtime *) let standard_library_default = c "standard_library_default" let standard_library = c "standard_library" let standard_runtime = c "standard_runtime" let bytecomp_c_compiler = c "bytecomp_c_compiler" let native_c_compiler = c "native_c_compiler" let model = c "model" let ext_obj = c "ext_obj" let ext_asm = c "ext_asm" let ext_lib = c "ext_lib" let ext_dll = c "ext_dll" let default_executable_name = c "default_executable_name" let systhread_supported = c "systhread_supported" let flexlink = BaseCheck.prog "flexlink" let flexdll_version = var_define ~short_desc:(fun () -> "FlexDLL version (Win32)") "flexdll_version" (fun () -> let lst = OASISExec.run_read_output ~ctxt:!BaseContext.default (flexlink ()) ["-help"] in match lst with | line :: _ -> Scanf.sscanf line "FlexDLL version %s" (fun ver -> ver) | [] -> raise Not_found) (**/**) let p name hlp dflt = var_define ~short_desc:hlp ~cli:CLIAuto ~arg_help:"dir" name dflt let (/) a b = if os_type () = Sys.os_type then Filename.concat a b else if os_type () = "Unix" then OASISUnixPath.concat a b else OASISUtils.failwithf (f_ "Cannot handle os_type %s filename concat") (os_type ()) (**/**) let prefix = p "prefix" (fun () -> s_ "Install architecture-independent files dir") (fun () -> match os_type () with | "Win32" -> let program_files = Sys.getenv "PROGRAMFILES" in program_files/(pkg_name ()) | _ -> "/usr/local") let exec_prefix = p "exec_prefix" (fun () -> s_ "Install architecture-dependent files in dir") (fun () -> "$prefix") let bindir = p "bindir" (fun () -> s_ "User executables") (fun () -> "$exec_prefix"/"bin") let sbindir = p "sbindir" (fun () -> s_ "System admin executables") (fun () -> "$exec_prefix"/"sbin") let libexecdir = p "libexecdir" (fun () -> s_ "Program executables") (fun () -> "$exec_prefix"/"libexec") let sysconfdir = p "sysconfdir" (fun () -> s_ "Read-only single-machine data") (fun () -> "$prefix"/"etc") let sharedstatedir = p "sharedstatedir" (fun () -> s_ "Modifiable architecture-independent data") (fun () -> "$prefix"/"com") let localstatedir = p "localstatedir" (fun () -> s_ "Modifiable single-machine data") (fun () -> "$prefix"/"var") let libdir = p "libdir" (fun () -> s_ "Object code libraries") (fun () -> "$exec_prefix"/"lib") let datarootdir = p "datarootdir" (fun () -> s_ "Read-only arch-independent data root") (fun () -> "$prefix"/"share") let datadir = p "datadir" (fun () -> s_ "Read-only architecture-independent data") (fun () -> "$datarootdir") let infodir = p "infodir" (fun () -> s_ "Info documentation") (fun () -> "$datarootdir"/"info") let localedir = p "localedir" (fun () -> s_ "Locale-dependent data") (fun () -> "$datarootdir"/"locale") let mandir = p "mandir" (fun () -> s_ "Man documentation") (fun () -> "$datarootdir"/"man") let docdir = p "docdir" (fun () -> s_ "Documentation root") (fun () -> "$datarootdir"/"doc"/"$pkg_name") let htmldir = p "htmldir" (fun () -> s_ "HTML documentation") (fun () -> "$docdir") let dvidir = p "dvidir" (fun () -> s_ "DVI documentation") (fun () -> "$docdir") let pdfdir = p "pdfdir" (fun () -> s_ "PDF documentation") (fun () -> "$docdir") let psdir = p "psdir" (fun () -> s_ "PS documentation") (fun () -> "$docdir") let destdir = p "destdir" (fun () -> s_ "Prepend a path when installing package") (fun () -> raise (PropList.Not_set ("destdir", Some (s_ "undefined by construct")))) let findlib_version = var_define "findlib_version" (fun () -> BaseCheck.package_version "findlib") let is_native = var_define "is_native" (fun () -> try let _s: string = ocamlopt () in "true" with PropList.Not_set _ -> let _s: string = ocamlc () in "false") let ext_program = var_define "suffix_program" (fun () -> match os_type () with | "Win32" | "Cygwin" -> ".exe" | _ -> "") let rm = var_define ~short_desc:(fun () -> s_ "Remove a file.") "rm" (fun () -> match os_type () with | "Win32" -> "del" | _ -> "rm -f") let rmdir = var_define ~short_desc:(fun () -> s_ "Remove a directory.") "rmdir" (fun () -> match os_type () with | "Win32" -> "rd" | _ -> "rm -rf") let debug = var_define ~short_desc:(fun () -> s_ "Turn ocaml debug flag on") ~cli:CLIEnable "debug" (fun () -> "true") let profile = var_define ~short_desc:(fun () -> s_ "Turn ocaml profile flag on") ~cli:CLIEnable "profile" (fun () -> "false") let tests = var_define_cond ~since_version:"0.3" (fun () -> var_define ~short_desc:(fun () -> s_ "Compile tests executable and library and run them") ~cli:CLIEnable "tests" (fun () -> "false")) "true" let docs = var_define_cond ~since_version:"0.3" (fun () -> var_define ~short_desc:(fun () -> s_ "Create documentations") ~cli:CLIEnable "docs" (fun () -> "true")) "true" let native_dynlink = var_define ~short_desc:(fun () -> s_ "Compiler support generation of .cmxs.") ~cli:CLINone "native_dynlink" (fun () -> let res = let ocaml_lt_312 () = OASISVersion.comparator_apply (OASISVersion.version_of_string (ocaml_version ())) (OASISVersion.VLesser (OASISVersion.version_of_string "3.12.0")) in let flexdll_lt_030 () = OASISVersion.comparator_apply (OASISVersion.version_of_string (flexdll_version ())) (OASISVersion.VLesser (OASISVersion.version_of_string "0.30")) in let has_native_dynlink = let ocamlfind = ocamlfind () in try let fn = OASISExec.run_read_one_line ~ctxt:!BaseContext.default ocamlfind ["query"; "-predicates"; "native"; "dynlink"; "-format"; "%d/%a"] in Sys.file_exists fn with _ -> false in if not has_native_dynlink then false else if ocaml_lt_312 () then false else if (os_type () = "Win32" || os_type () = "Cygwin") && flexdll_lt_030 () then begin BaseMessage.warning (f_ ".cmxs generation disabled because FlexDLL needs to be \ at least 0.30. Please upgrade FlexDLL from %s to 0.30.") (flexdll_version ()); false end else true in string_of_bool res) let init pkg = rpkg := Some pkg; List.iter (fun f -> f pkg.oasis_version) !var_cond end module BaseFileAB = struct (* # 22 "src/base/BaseFileAB.ml" *) open BaseEnv open OASISGettext open BaseMessage let to_filename fn = let fn = OASISHostPath.of_unix fn in if not (Filename.check_suffix fn ".ab") then warning (f_ "File '%s' doesn't have '.ab' extension") fn; Filename.chop_extension fn let replace fn_lst = let buff = Buffer.create 13 in List.iter (fun fn -> let fn = OASISHostPath.of_unix fn in let chn_in = open_in fn in let chn_out = open_out (to_filename fn) in ( try while true do Buffer.add_string buff (var_expand (input_line chn_in)); Buffer.add_char buff '\n' done with End_of_file -> () ); Buffer.output_buffer chn_out buff; Buffer.clear buff; close_in chn_in; close_out chn_out) fn_lst end module BaseLog = struct (* # 22 "src/base/BaseLog.ml" *) open OASISUtils let default_filename = Filename.concat (Filename.dirname BaseEnv.default_filename) "setup.log" module SetTupleString = Set.Make (struct type t = string * string let compare (s11, s12) (s21, s22) = match String.compare s11 s21 with | 0 -> String.compare s12 s22 | n -> n end) let load () = if Sys.file_exists default_filename then begin let chn = open_in default_filename in let scbuf = Scanf.Scanning.from_file default_filename in let rec read_aux (st, lst) = if not (Scanf.Scanning.end_of_input scbuf) then begin let acc = try Scanf.bscanf scbuf "%S %S\n" (fun e d -> let t = e, d in if SetTupleString.mem t st then st, lst else SetTupleString.add t st, t :: lst) with Scanf.Scan_failure _ -> failwith (Scanf.bscanf scbuf "%l" (fun line -> Printf.sprintf "Malformed log file '%s' at line %d" default_filename line)) in read_aux acc end else begin close_in chn; List.rev lst end in read_aux (SetTupleString.empty, []) end else begin [] end let register event data = let chn_out = open_out_gen [Open_append; Open_creat; Open_text] 0o644 default_filename in Printf.fprintf chn_out "%S %S\n" event data; close_out chn_out let unregister event data = if Sys.file_exists default_filename then begin let lst = load () in let chn_out = open_out default_filename in let write_something = ref false in List.iter (fun (e, d) -> if e <> event || d <> data then begin write_something := true; Printf.fprintf chn_out "%S %S\n" e d end) lst; close_out chn_out; if not !write_something then Sys.remove default_filename end let filter events = let st_events = List.fold_left (fun st e -> SetString.add e st) SetString.empty events in List.filter (fun (e, _) -> SetString.mem e st_events) (load ()) let exists event data = List.exists (fun v -> (event, data) = v) (load ()) end module BaseBuilt = struct (* # 22 "src/base/BaseBuilt.ml" *) open OASISTypes open OASISGettext open BaseStandardVar open BaseMessage type t = | BExec (* Executable *) | BExecLib (* Library coming with executable *) | BLib (* Library *) | BObj (* Library *) | BDoc (* Document *) let to_log_event_file t nm = "built_"^ (match t with | BExec -> "exec" | BExecLib -> "exec_lib" | BLib -> "lib" | BObj -> "obj" | BDoc -> "doc")^ "_"^nm let to_log_event_done t nm = "is_"^(to_log_event_file t nm) let register t nm lst = BaseLog.register (to_log_event_done t nm) "true"; List.iter (fun alt -> let registered = List.fold_left (fun registered fn -> if OASISFileUtil.file_exists_case fn then begin BaseLog.register (to_log_event_file t nm) (if Filename.is_relative fn then Filename.concat (Sys.getcwd ()) fn else fn); true end else registered) false alt in if not registered then warning (f_ "Cannot find an existing alternative files among: %s") (String.concat (s_ ", ") alt)) lst let unregister t nm = List.iter (fun (e, d) -> BaseLog.unregister e d) (BaseLog.filter [to_log_event_file t nm; to_log_event_done t nm]) let fold t nm f acc = List.fold_left (fun acc (_, fn) -> if OASISFileUtil.file_exists_case fn then begin f acc fn end else begin warning (f_ "File '%s' has been marked as built \ for %s but doesn't exist") fn (Printf.sprintf (match t with | BExec | BExecLib -> (f_ "executable %s") | BLib -> (f_ "library %s") | BObj -> (f_ "object %s") | BDoc -> (f_ "documentation %s")) nm); acc end) acc (BaseLog.filter [to_log_event_file t nm]) let is_built t nm = List.fold_left (fun is_built (_, d) -> (try bool_of_string d with _ -> false)) false (BaseLog.filter [to_log_event_done t nm]) let of_executable ffn (cs, bs, exec) = let unix_exec_is, unix_dll_opt = OASISExecutable.unix_exec_is (cs, bs, exec) (fun () -> bool_of_string (is_native ())) ext_dll ext_program in let evs = (BExec, cs.cs_name, [[ffn unix_exec_is]]) :: (match unix_dll_opt with | Some fn -> [BExecLib, cs.cs_name, [[ffn fn]]] | None -> []) in evs, unix_exec_is, unix_dll_opt let of_library ffn (cs, bs, lib) = let unix_lst = OASISLibrary.generated_unix_files ~ctxt:!BaseContext.default ~source_file_exists:(fun fn -> OASISFileUtil.file_exists_case (OASISHostPath.of_unix fn)) ~is_native:(bool_of_string (is_native ())) ~has_native_dynlink:(bool_of_string (native_dynlink ())) ~ext_lib:(ext_lib ()) ~ext_dll:(ext_dll ()) (cs, bs, lib) in let evs = [BLib, cs.cs_name, List.map (List.map ffn) unix_lst] in evs, unix_lst let of_object ffn (cs, bs, obj) = let unix_lst = OASISObject.generated_unix_files ~ctxt:!BaseContext.default ~source_file_exists:(fun fn -> OASISFileUtil.file_exists_case (OASISHostPath.of_unix fn)) ~is_native:(bool_of_string (is_native ())) (cs, bs, obj) in let evs = [BObj, cs.cs_name, List.map (List.map ffn) unix_lst] in evs, unix_lst end module BaseCustom = struct (* # 22 "src/base/BaseCustom.ml" *) open BaseEnv open BaseMessage open OASISTypes open OASISGettext let run cmd args extra_args = OASISExec.run ~ctxt:!BaseContext.default ~quote:false (var_expand cmd) (List.map var_expand (args @ (Array.to_list extra_args))) let hook ?(failsafe=false) cstm f e = let optional_command lst = let printer = function | Some (cmd, args) -> String.concat " " (cmd :: args) | None -> s_ "No command" in match var_choose ~name:(s_ "Pre/Post Command") ~printer lst with | Some (cmd, args) -> begin try run cmd args [||] with e when failsafe -> warning (f_ "Command '%s' fail with error: %s") (String.concat " " (cmd :: args)) (match e with | Failure msg -> msg | e -> Printexc.to_string e) end | None -> () in let res = optional_command cstm.pre_command; f e in optional_command cstm.post_command; res end module BaseDynVar = struct (* # 22 "src/base/BaseDynVar.ml" *) open OASISTypes open OASISGettext open BaseEnv open BaseBuilt let init pkg = (* TODO: disambiguate exec vs other variable by adding exec_VARNAME. *) (* TODO: provide compile option for library libary_byte_args_VARNAME... *) List.iter (function | Executable (cs, bs, exec) -> if var_choose bs.bs_build then var_ignore (var_redefine (* We don't save this variable *) ~dump:false ~short_desc:(fun () -> Printf.sprintf (f_ "Filename of executable '%s'") cs.cs_name) (OASISUtils.varname_of_string cs.cs_name) (fun () -> let fn_opt = fold BExec cs.cs_name (fun _ fn -> Some fn) None in match fn_opt with | Some fn -> fn | None -> raise (PropList.Not_set (cs.cs_name, Some (Printf.sprintf (f_ "Executable '%s' not yet built.") cs.cs_name))))) | Library _ | Object _ | Flag _ | Test _ | SrcRepo _ | Doc _ -> ()) pkg.sections end module BaseTest = struct (* # 22 "src/base/BaseTest.ml" *) open BaseEnv open BaseMessage open OASISTypes open OASISExpr open OASISGettext let test lst pkg extra_args = let one_test (failure, n) (test_plugin, cs, test) = if var_choose ~name:(Printf.sprintf (f_ "test %s run") cs.cs_name) ~printer:string_of_bool test.test_run then begin let () = info (f_ "Running test '%s'") cs.cs_name in let back_cwd = match test.test_working_directory with | Some dir -> let cwd = Sys.getcwd () in let chdir d = info (f_ "Changing directory to '%s'") d; Sys.chdir d in chdir dir; fun () -> chdir cwd | None -> fun () -> () in try let failure_percent = BaseCustom.hook test.test_custom (test_plugin pkg (cs, test)) extra_args in back_cwd (); (failure_percent +. failure, n + 1) with e -> begin back_cwd (); raise e end end else begin info (f_ "Skipping test '%s'") cs.cs_name; (failure, n) end in let failed, n = List.fold_left one_test (0.0, 0) lst in let failure_percent = if n = 0 then 0.0 else failed /. (float_of_int n) in let msg = Printf.sprintf (f_ "Tests had a %.2f%% failure rate") (100. *. failure_percent) in if failure_percent > 0.0 then failwith msg else info "%s" msg; (* Possible explanation why the tests where not run. *) if OASISFeatures.package_test OASISFeatures.flag_tests pkg && not (bool_of_string (BaseStandardVar.tests ())) && lst <> [] then BaseMessage.warning "Tests are turned off, consider enabling with \ 'ocaml setup.ml -configure --enable-tests'" end module BaseDoc = struct (* # 22 "src/base/BaseDoc.ml" *) open BaseEnv open BaseMessage open OASISTypes open OASISGettext let doc lst pkg extra_args = let one_doc (doc_plugin, cs, doc) = if var_choose ~name:(Printf.sprintf (f_ "documentation %s build") cs.cs_name) ~printer:string_of_bool doc.doc_build then begin info (f_ "Building documentation '%s'") cs.cs_name; BaseCustom.hook doc.doc_custom (doc_plugin pkg (cs, doc)) extra_args end in List.iter one_doc lst; if OASISFeatures.package_test OASISFeatures.flag_docs pkg && not (bool_of_string (BaseStandardVar.docs ())) && lst <> [] then BaseMessage.warning "Docs are turned off, consider enabling with \ 'ocaml setup.ml -configure --enable-docs'" end module BaseSetup = struct (* # 22 "src/base/BaseSetup.ml" *) open BaseEnv open BaseMessage open OASISTypes open OASISSection open OASISGettext open OASISUtils type std_args_fun = package -> string array -> unit type ('a, 'b) section_args_fun = name * (package -> (common_section * 'a) -> string array -> 'b) type t = { configure: std_args_fun; build: std_args_fun; doc: ((doc, unit) section_args_fun) list; test: ((test, float) section_args_fun) list; install: std_args_fun; uninstall: std_args_fun; clean: std_args_fun list; clean_doc: (doc, unit) section_args_fun list; clean_test: (test, unit) section_args_fun list; distclean: std_args_fun list; distclean_doc: (doc, unit) section_args_fun list; distclean_test: (test, unit) section_args_fun list; package: package; oasis_fn: string option; oasis_version: string; oasis_digest: Digest.t option; oasis_exec: string option; oasis_setup_args: string list; setup_update: bool; } (* Associate a plugin function with data from package *) let join_plugin_sections filter_map lst = List.rev (List.fold_left (fun acc sct -> match filter_map sct with | Some e -> e :: acc | None -> acc) [] lst) (* Search for plugin data associated with a section name *) let lookup_plugin_section plugin action nm lst = try List.assoc nm lst with Not_found -> failwithf (f_ "Cannot find plugin %s matching section %s for %s action") plugin nm action let configure t args = (* Run configure *) BaseCustom.hook t.package.conf_custom (fun () -> (* Reload if preconf has changed it *) begin try unload (); load (); with _ -> () end; (* Run plugin's configure *) t.configure t.package args; (* Dump to allow postconf to change it *) dump ()) (); (* Reload environment *) unload (); load (); (* Save environment *) print (); (* Replace data in file *) BaseFileAB.replace t.package.files_ab let build t args = BaseCustom.hook t.package.build_custom (t.build t.package) args let doc t args = BaseDoc.doc (join_plugin_sections (function | Doc (cs, e) -> Some (lookup_plugin_section "documentation" (s_ "build") cs.cs_name t.doc, cs, e) | _ -> None) t.package.sections) t.package args let test t args = BaseTest.test (join_plugin_sections (function | Test (cs, e) -> Some (lookup_plugin_section "test" (s_ "run") cs.cs_name t.test, cs, e) | _ -> None) t.package.sections) t.package args let all t args = let rno_doc = ref false in let rno_test = ref false in let arg_rest = ref [] in Arg.parse_argv ~current:(ref 0) (Array.of_list ((Sys.executable_name^" all") :: (Array.to_list args))) [ "-no-doc", Arg.Set rno_doc, s_ "Don't run doc target"; "-no-test", Arg.Set rno_test, s_ "Don't run test target"; "--", Arg.Rest (fun arg -> arg_rest := arg :: !arg_rest), s_ "All arguments for configure."; ] (failwithf (f_ "Don't know what to do with '%s'")) ""; info "Running configure step"; configure t (Array.of_list (List.rev !arg_rest)); info "Running build step"; build t [||]; (* Load setup.log dynamic variables *) BaseDynVar.init t.package; if not !rno_doc then begin info "Running doc step"; doc t [||]; end else begin info "Skipping doc step" end; if not !rno_test then begin info "Running test step"; test t [||] end else begin info "Skipping test step" end let install t args = BaseCustom.hook t.package.install_custom (t.install t.package) args let uninstall t args = BaseCustom.hook t.package.uninstall_custom (t.uninstall t.package) args let reinstall t args = uninstall t args; install t args let clean, distclean = let failsafe f a = try f a with e -> warning (f_ "Action fail with error: %s") (match e with | Failure msg -> msg | e -> Printexc.to_string e) in let generic_clean t cstm mains docs tests args = BaseCustom.hook ~failsafe:true cstm (fun () -> (* Clean section *) List.iter (function | Test (cs, test) -> let f = try List.assoc cs.cs_name tests with Not_found -> fun _ _ _ -> () in failsafe (f t.package (cs, test)) args | Doc (cs, doc) -> let f = try List.assoc cs.cs_name docs with Not_found -> fun _ _ _ -> () in failsafe (f t.package (cs, doc)) args | Library _ | Object _ | Executable _ | Flag _ | SrcRepo _ -> ()) t.package.sections; (* Clean whole package *) List.iter (fun f -> failsafe (f t.package) args) mains) () in let clean t args = generic_clean t t.package.clean_custom t.clean t.clean_doc t.clean_test args in let distclean t args = (* Call clean *) clean t args; (* Call distclean code *) generic_clean t t.package.distclean_custom t.distclean t.distclean_doc t.distclean_test args; (* Remove generated file *) List.iter (fun fn -> if Sys.file_exists fn then begin info (f_ "Remove '%s'") fn; Sys.remove fn end) (BaseEnv.default_filename :: BaseLog.default_filename :: (List.rev_map BaseFileAB.to_filename t.package.files_ab)) in clean, distclean let version t _ = print_endline t.oasis_version let update_setup_ml, no_update_setup_ml_cli = let b = ref true in b, ("-no-update-setup-ml", Arg.Clear b, s_ " Don't try to update setup.ml, even if _oasis has changed.") let default_oasis_fn = "_oasis" let update_setup_ml t = let oasis_fn = match t.oasis_fn with | Some fn -> fn | None -> default_oasis_fn in let oasis_exec = match t.oasis_exec with | Some fn -> fn | None -> "oasis" in let ocaml = Sys.executable_name in let setup_ml, args = match Array.to_list Sys.argv with | setup_ml :: args -> setup_ml, args | [] -> failwith (s_ "Expecting non-empty command line arguments.") in let ocaml, setup_ml = if Sys.executable_name = Sys.argv.(0) then (* We are not running in standard mode, probably the script * is precompiled. *) "ocaml", "setup.ml" else ocaml, setup_ml in let no_update_setup_ml_cli, _, _ = no_update_setup_ml_cli in let do_update () = let oasis_exec_version = OASISExec.run_read_one_line ~ctxt:!BaseContext.default ~f_exit_code: (function | 0 -> () | 1 -> failwithf (f_ "Executable '%s' is probably an old version \ of oasis (< 0.3.0), please update to version \ v%s.") oasis_exec t.oasis_version | 127 -> failwithf (f_ "Cannot find executable '%s', please install \ oasis v%s.") oasis_exec t.oasis_version | n -> failwithf (f_ "Command '%s version' exited with code %d.") oasis_exec n) oasis_exec ["version"] in if OASISVersion.comparator_apply (OASISVersion.version_of_string oasis_exec_version) (OASISVersion.VGreaterEqual (OASISVersion.version_of_string t.oasis_version)) then begin (* We have a version >= for the executable oasis, proceed with * update. *) (* TODO: delegate this check to 'oasis setup'. *) if Sys.os_type = "Win32" then failwithf (f_ "It is not possible to update the running script \ setup.ml on Windows. Please update setup.ml by \ running '%s'.") (String.concat " " (oasis_exec :: "setup" :: t.oasis_setup_args)) else begin OASISExec.run ~ctxt:!BaseContext.default ~f_exit_code: (function | 0 -> () | n -> failwithf (f_ "Unable to update setup.ml using '%s', \ please fix the problem and retry.") oasis_exec) oasis_exec ("setup" :: t.oasis_setup_args); OASISExec.run ~ctxt:!BaseContext.default ocaml (setup_ml :: args) end end else failwithf (f_ "The version of '%s' (v%s) doesn't match the version of \ oasis used to generate the %s file. Please install at \ least oasis v%s.") oasis_exec oasis_exec_version setup_ml t.oasis_version in if !update_setup_ml then begin try match t.oasis_digest with | Some dgst -> if Sys.file_exists oasis_fn && dgst <> Digest.file default_oasis_fn then begin do_update (); true end else false | None -> false with e -> error (f_ "Error when updating setup.ml. If you want to avoid this error, \ you can bypass the update of %s by running '%s %s %s %s'") setup_ml ocaml setup_ml no_update_setup_ml_cli (String.concat " " args); raise e end else false let setup t = let catch_exn = ref true in try let act_ref = ref (fun _ -> failwithf (f_ "No action defined, run '%s %s -help'") Sys.executable_name Sys.argv.(0)) in let extra_args_ref = ref [] in let allow_empty_env_ref = ref false in let arg_handle ?(allow_empty_env=false) act = Arg.Tuple [ Arg.Rest (fun str -> extra_args_ref := str :: !extra_args_ref); Arg.Unit (fun () -> allow_empty_env_ref := allow_empty_env; act_ref := act); ] in Arg.parse (Arg.align ([ "-configure", arg_handle ~allow_empty_env:true configure, s_ "[options*] Configure the whole build process."; "-build", arg_handle build, s_ "[options*] Build executables and libraries."; "-doc", arg_handle doc, s_ "[options*] Build documents."; "-test", arg_handle test, s_ "[options*] Run tests."; "-all", arg_handle ~allow_empty_env:true all, s_ "[options*] Run configure, build, doc and test targets."; "-install", arg_handle install, s_ "[options*] Install libraries, data, executables \ and documents."; "-uninstall", arg_handle uninstall, s_ "[options*] Uninstall libraries, data, executables \ and documents."; "-reinstall", arg_handle reinstall, s_ "[options*] Uninstall and install libraries, data, \ executables and documents."; "-clean", arg_handle ~allow_empty_env:true clean, s_ "[options*] Clean files generated by a build."; "-distclean", arg_handle ~allow_empty_env:true distclean, s_ "[options*] Clean files generated by a build and configure."; "-version", arg_handle ~allow_empty_env:true version, s_ " Display version of OASIS used to generate this setup.ml."; "-no-catch-exn", Arg.Clear catch_exn, s_ " Don't catch exception, useful for debugging."; ] @ (if t.setup_update then [no_update_setup_ml_cli] else []) @ (BaseContext.args ()))) (failwithf (f_ "Don't know what to do with '%s'")) (s_ "Setup and run build process current package\n"); (* Build initial environment *) load ~allow_empty:!allow_empty_env_ref (); (** Initialize flags *) List.iter (function | Flag (cs, {flag_description = hlp; flag_default = choices}) -> begin let apply ?short_desc () = var_ignore (var_define ~cli:CLIEnable ?short_desc (OASISUtils.varname_of_string cs.cs_name) (fun () -> string_of_bool (var_choose ~name:(Printf.sprintf (f_ "default value of flag %s") cs.cs_name) ~printer:string_of_bool choices))) in match hlp with | Some hlp -> apply ~short_desc:(fun () -> hlp) () | None -> apply () end | _ -> ()) t.package.sections; BaseStandardVar.init t.package; BaseDynVar.init t.package; if t.setup_update && update_setup_ml t then () else !act_ref t (Array.of_list (List.rev !extra_args_ref)) with e when !catch_exn -> error "%s" (Printexc.to_string e); exit 1 end # 5409 "setup.ml" module InternalConfigurePlugin = struct (* # 22 "src/plugins/internal/InternalConfigurePlugin.ml" *) (** Configure using internal scheme @author Sylvain Le Gall *) open BaseEnv open OASISTypes open OASISUtils open OASISGettext open BaseMessage (** Configure build using provided series of check to be done * and then output corresponding file. *) let configure pkg argv = let var_ignore_eval var = let _s: string = var () in () in let errors = ref SetString.empty in let buff = Buffer.create 13 in let add_errors fmt = Printf.kbprintf (fun b -> errors := SetString.add (Buffer.contents b) !errors; Buffer.clear b) buff fmt in let warn_exception e = warning "%s" (Printexc.to_string e) in (* Check tools *) let check_tools lst = List.iter (function | ExternalTool tool -> begin try var_ignore_eval (BaseCheck.prog tool) with e -> warn_exception e; add_errors (f_ "Cannot find external tool '%s'") tool end | InternalExecutable nm1 -> (* Check that matching tool is built *) List.iter (function | Executable ({cs_name = nm2}, {bs_build = build}, _) when nm1 = nm2 -> if not (var_choose build) then add_errors (f_ "Cannot find buildable internal executable \ '%s' when checking build depends") nm1 | _ -> ()) pkg.sections) lst in let build_checks sct bs = if var_choose bs.bs_build then begin if bs.bs_compiled_object = Native then begin try var_ignore_eval BaseStandardVar.ocamlopt with e -> warn_exception e; add_errors (f_ "Section %s requires native compilation") (OASISSection.string_of_section sct) end; (* Check tools *) check_tools bs.bs_build_tools; (* Check depends *) List.iter (function | FindlibPackage (findlib_pkg, version_comparator) -> begin try var_ignore_eval (BaseCheck.package ?version_comparator findlib_pkg) with e -> warn_exception e; match version_comparator with | None -> add_errors (f_ "Cannot find findlib package %s") findlib_pkg | Some ver_cmp -> add_errors (f_ "Cannot find findlib package %s (%s)") findlib_pkg (OASISVersion.string_of_comparator ver_cmp) end | InternalLibrary nm1 -> (* Check that matching library is built *) List.iter (function | Library ({cs_name = nm2}, {bs_build = build}, _) when nm1 = nm2 -> if not (var_choose build) then add_errors (f_ "Cannot find buildable internal library \ '%s' when checking build depends") nm1 | _ -> ()) pkg.sections) bs.bs_build_depends end in (* Parse command line *) BaseArgExt.parse argv (BaseEnv.args ()); (* OCaml version *) begin match pkg.ocaml_version with | Some ver_cmp -> begin try var_ignore_eval (BaseCheck.version "ocaml" ver_cmp BaseStandardVar.ocaml_version) with e -> warn_exception e; add_errors (f_ "OCaml version %s doesn't match version constraint %s") (BaseStandardVar.ocaml_version ()) (OASISVersion.string_of_comparator ver_cmp) end | None -> () end; (* Findlib version *) begin match pkg.findlib_version with | Some ver_cmp -> begin try var_ignore_eval (BaseCheck.version "findlib" ver_cmp BaseStandardVar.findlib_version) with e -> warn_exception e; add_errors (f_ "Findlib version %s doesn't match version constraint %s") (BaseStandardVar.findlib_version ()) (OASISVersion.string_of_comparator ver_cmp) end | None -> () end; (* Make sure the findlib version is fine for the OCaml compiler. *) begin let ocaml_ge4 = OASISVersion.version_compare (OASISVersion.version_of_string (BaseStandardVar.ocaml_version())) (OASISVersion.version_of_string "4.0.0") >= 0 in if ocaml_ge4 then let findlib_lt132 = OASISVersion.version_compare (OASISVersion.version_of_string (BaseStandardVar.findlib_version())) (OASISVersion.version_of_string "1.3.2") < 0 in if findlib_lt132 then add_errors "OCaml >= 4.0.0 requires Findlib version >= 1.3.2" end; (* FlexDLL *) if BaseStandardVar.os_type () = "Win32" || BaseStandardVar.os_type () = "Cygwin" then begin try var_ignore_eval BaseStandardVar.flexlink with e -> warn_exception e; add_errors (f_ "Cannot find 'flexlink'") end; (* Check build depends *) List.iter (function | Executable (_, bs, _) | Library (_, bs, _) as sct -> build_checks sct bs | Doc (_, doc) -> if var_choose doc.doc_build then check_tools doc.doc_build_tools | Test (_, test) -> if var_choose test.test_run then check_tools test.test_tools | _ -> ()) pkg.sections; (* Check if we need native dynlink (presence of libraries that compile to * native) *) begin let has_cmxa = List.exists (function | Library (_, bs, _) -> var_choose bs.bs_build && (bs.bs_compiled_object = Native || (bs.bs_compiled_object = Best && bool_of_string (BaseStandardVar.is_native ()))) | _ -> false) pkg.sections in if has_cmxa then var_ignore_eval BaseStandardVar.native_dynlink end; (* Check errors *) if SetString.empty != !errors then begin List.iter (fun e -> error "%s" e) (SetString.elements !errors); failwithf (fn_ "%d configuration error" "%d configuration errors" (SetString.cardinal !errors)) (SetString.cardinal !errors) end end module InternalInstallPlugin = struct (* # 22 "src/plugins/internal/InternalInstallPlugin.ml" *) (** Install using internal scheme @author Sylvain Le Gall *) open BaseEnv open BaseStandardVar open BaseMessage open OASISTypes open OASISFindlib open OASISGettext open OASISUtils let exec_hook = ref (fun (cs, bs, exec) -> cs, bs, exec) let lib_hook = ref (fun (cs, bs, lib) -> cs, bs, lib, []) let obj_hook = ref (fun (cs, bs, obj) -> cs, bs, obj, []) let doc_hook = ref (fun (cs, doc) -> cs, doc) let install_file_ev = "install-file" let install_dir_ev = "install-dir" let install_findlib_ev = "install-findlib" let win32_max_command_line_length = 8000 let split_install_command ocamlfind findlib_name meta files = if Sys.os_type = "Win32" then (* Arguments for the first command: *) let first_args = ["install"; findlib_name; meta] in (* Arguments for remaining commands: *) let other_args = ["install"; findlib_name; "-add"] in (* Extract as much files as possible from [files], [len] is the current command line length: *) let rec get_files len acc files = match files with | [] -> (List.rev acc, []) | file :: rest -> let len = len + 1 + String.length file in if len > win32_max_command_line_length then (List.rev acc, files) else get_files len (file :: acc) rest in (* Split the command into several commands. *) let rec split args files = match files with | [] -> [] | _ -> (* Length of "ocamlfind install [META|-add]" *) let len = List.fold_left (fun len arg -> len + 1 (* for the space *) + String.length arg) (String.length ocamlfind) args in match get_files len [] files with | ([], _) -> failwith (s_ "Command line too long.") | (firsts, others) -> let cmd = args @ firsts in (* Use -add for remaining commands: *) let () = let findlib_ge_132 = OASISVersion.comparator_apply (OASISVersion.version_of_string (BaseStandardVar.findlib_version ())) (OASISVersion.VGreaterEqual (OASISVersion.version_of_string "1.3.2")) in if not findlib_ge_132 then failwithf (f_ "Installing the library %s require to use the \ flag '-add' of ocamlfind because the command \ line is too long. This flag is only available \ for findlib 1.3.2. Please upgrade findlib from \ %s to 1.3.2") findlib_name (BaseStandardVar.findlib_version ()) in let cmds = split other_args others in cmd :: cmds in (* The first command does not use -add: *) split first_args files else ["install" :: findlib_name :: meta :: files] let install pkg argv = let in_destdir = try let destdir = destdir () in (* Practically speaking destdir is prepended * at the beginning of the target filename *) fun fn -> destdir^fn with PropList.Not_set _ -> fun fn -> fn in let install_file ?tgt_fn src_file envdir = let tgt_dir = in_destdir (envdir ()) in let tgt_file = Filename.concat tgt_dir (match tgt_fn with | Some fn -> fn | None -> Filename.basename src_file) in (* Create target directory if needed *) OASISFileUtil.mkdir_parent ~ctxt:!BaseContext.default (fun dn -> info (f_ "Creating directory '%s'") dn; BaseLog.register install_dir_ev dn) tgt_dir; (* Really install files *) info (f_ "Copying file '%s' to '%s'") src_file tgt_file; OASISFileUtil.cp ~ctxt:!BaseContext.default src_file tgt_file; BaseLog.register install_file_ev tgt_file in (* Install data into defined directory *) let install_data srcdir lst tgtdir = let tgtdir = OASISHostPath.of_unix (var_expand tgtdir) in List.iter (fun (src, tgt_opt) -> let real_srcs = OASISFileUtil.glob ~ctxt:!BaseContext.default (Filename.concat srcdir src) in if real_srcs = [] then failwithf (f_ "Wildcard '%s' doesn't match any files") src; List.iter (fun fn -> install_file fn (fun () -> match tgt_opt with | Some s -> OASISHostPath.of_unix (var_expand s) | None -> tgtdir)) real_srcs) lst in let make_fnames modul sufx = List.fold_right begin fun sufx accu -> (String.capitalize modul ^ sufx) :: (String.uncapitalize modul ^ sufx) :: accu end sufx [] in (** Install all libraries *) let install_libs pkg = let files_of_library (f_data, acc) data_lib = let cs, bs, lib, lib_extra = !lib_hook data_lib in if var_choose bs.bs_install && BaseBuilt.is_built BaseBuilt.BLib cs.cs_name then begin let acc = (* Start with acc + lib_extra *) List.rev_append lib_extra acc in let acc = (* Add uncompiled header from the source tree *) let path = OASISHostPath.of_unix bs.bs_path in List.fold_left begin fun acc modul -> begin try [List.find OASISFileUtil.file_exists_case (List.map (Filename.concat path) (make_fnames modul [".mli"; ".ml"]))] with Not_found -> warning (f_ "Cannot find source header for module %s \ in library %s") modul cs.cs_name; [] end @ List.filter OASISFileUtil.file_exists_case (List.map (Filename.concat path) (make_fnames modul [".annot";".cmti";".cmt"])) @ acc end acc lib.lib_modules in let acc = (* Get generated files *) BaseBuilt.fold BaseBuilt.BLib cs.cs_name (fun acc fn -> fn :: acc) acc in let f_data () = (* Install data associated with the library *) install_data bs.bs_path bs.bs_data_files (Filename.concat (datarootdir ()) pkg.name); f_data () in (f_data, acc) end else begin (f_data, acc) end and files_of_object (f_data, acc) data_obj = let cs, bs, obj, obj_extra = !obj_hook data_obj in if var_choose bs.bs_install && BaseBuilt.is_built BaseBuilt.BObj cs.cs_name then begin let acc = (* Start with acc + obj_extra *) List.rev_append obj_extra acc in let acc = (* Add uncompiled header from the source tree *) let path = OASISHostPath.of_unix bs.bs_path in List.fold_left begin fun acc modul -> begin try [List.find OASISFileUtil.file_exists_case (List.map (Filename.concat path) (make_fnames modul [".mli"; ".ml"]))] with Not_found -> warning (f_ "Cannot find source header for module %s \ in object %s") modul cs.cs_name; [] end @ List.filter OASISFileUtil.file_exists_case (List.map (Filename.concat path) (make_fnames modul [".annot";".cmti";".cmt"])) @ acc end acc obj.obj_modules in let acc = (* Get generated files *) BaseBuilt.fold BaseBuilt.BObj cs.cs_name (fun acc fn -> fn :: acc) acc in let f_data () = (* Install data associated with the object *) install_data bs.bs_path bs.bs_data_files (Filename.concat (datarootdir ()) pkg.name); f_data () in (f_data, acc) end else begin (f_data, acc) end in (* Install one group of library *) let install_group_lib grp = (* Iterate through all group nodes *) let rec install_group_lib_aux data_and_files grp = let data_and_files, children = match grp with | Container (_, children) -> data_and_files, children | Package (_, cs, bs, `Library lib, children) -> files_of_library data_and_files (cs, bs, lib), children | Package (_, cs, bs, `Object obj, children) -> files_of_object data_and_files (cs, bs, obj), children in List.fold_left install_group_lib_aux data_and_files children in (* Findlib name of the root library *) let findlib_name = findlib_of_group grp in (* Determine root library *) let root_lib = root_of_group grp in (* All files to install for this library *) let f_data, files = install_group_lib_aux (ignore, []) grp in (* Really install, if there is something to install *) if files = [] then begin warning (f_ "Nothing to install for findlib library '%s'") findlib_name end else begin let meta = (* Search META file *) let _, bs, _ = root_lib in let res = Filename.concat bs.bs_path "META" in if not (OASISFileUtil.file_exists_case res) then failwithf (f_ "Cannot find file '%s' for findlib library %s") res findlib_name; res in let files = (* Make filename shorter to avoid hitting command max line length * too early, esp. on Windows. *) let remove_prefix p n = let plen = String.length p in let nlen = String.length n in if plen <= nlen && String.sub n 0 plen = p then begin let fn_sep = if Sys.os_type = "Win32" then '\\' else '/' in let cutpoint = plen + (if plen < nlen && n.[plen] = fn_sep then 1 else 0) in String.sub n cutpoint (nlen - cutpoint) end else n in List.map (remove_prefix (Sys.getcwd ())) files in info (f_ "Installing findlib library '%s'") findlib_name; let ocamlfind = ocamlfind () in let commands = split_install_command ocamlfind findlib_name meta files in List.iter (OASISExec.run ~ctxt:!BaseContext.default ocamlfind) commands; BaseLog.register install_findlib_ev findlib_name end; (* Install data files *) f_data (); in let group_libs, _, _ = findlib_mapping pkg in (* We install libraries in groups *) List.iter install_group_lib group_libs in let install_execs pkg = let install_exec data_exec = let cs, bs, exec = !exec_hook data_exec in if var_choose bs.bs_install && BaseBuilt.is_built BaseBuilt.BExec cs.cs_name then begin let exec_libdir () = Filename.concat (libdir ()) pkg.name in BaseBuilt.fold BaseBuilt.BExec cs.cs_name (fun () fn -> install_file ~tgt_fn:(cs.cs_name ^ ext_program ()) fn bindir) (); BaseBuilt.fold BaseBuilt.BExecLib cs.cs_name (fun () fn -> install_file fn exec_libdir) (); install_data bs.bs_path bs.bs_data_files (Filename.concat (datarootdir ()) pkg.name) end in List.iter (function | Executable (cs, bs, exec)-> install_exec (cs, bs, exec) | _ -> ()) pkg.sections in let install_docs pkg = let install_doc data = let cs, doc = !doc_hook data in if var_choose doc.doc_install && BaseBuilt.is_built BaseBuilt.BDoc cs.cs_name then begin let tgt_dir = OASISHostPath.of_unix (var_expand doc.doc_install_dir) in BaseBuilt.fold BaseBuilt.BDoc cs.cs_name (fun () fn -> install_file fn (fun () -> tgt_dir)) (); install_data Filename.current_dir_name doc.doc_data_files doc.doc_install_dir end in List.iter (function | Doc (cs, doc) -> install_doc (cs, doc) | _ -> ()) pkg.sections in install_libs pkg; install_execs pkg; install_docs pkg (* Uninstall already installed data *) let uninstall _ argv = List.iter (fun (ev, data) -> if ev = install_file_ev then begin if OASISFileUtil.file_exists_case data then begin info (f_ "Removing file '%s'") data; Sys.remove data end else begin warning (f_ "File '%s' doesn't exist anymore") data end end else if ev = install_dir_ev then begin if Sys.file_exists data && Sys.is_directory data then begin if Sys.readdir data = [||] then begin info (f_ "Removing directory '%s'") data; OASISFileUtil.rmdir ~ctxt:!BaseContext.default data end else begin warning (f_ "Directory '%s' is not empty (%s)") data (String.concat ", " (Array.to_list (Sys.readdir data))) end end else begin warning (f_ "Directory '%s' doesn't exist anymore") data end end else if ev = install_findlib_ev then begin info (f_ "Removing findlib library '%s'") data; OASISExec.run ~ctxt:!BaseContext.default (ocamlfind ()) ["remove"; data] end else failwithf (f_ "Unknown log event '%s'") ev; BaseLog.unregister ev data) (* We process event in reverse order *) (List.rev (BaseLog.filter [install_file_ev; install_dir_ev; install_findlib_ev])) end # 6273 "setup.ml" module OCamlbuildCommon = struct (* # 22 "src/plugins/ocamlbuild/OCamlbuildCommon.ml" *) (** Functions common to OCamlbuild build and doc plugin *) open OASISGettext open BaseEnv open BaseStandardVar open OASISTypes type extra_args = string list let ocamlbuild_clean_ev = "ocamlbuild-clean" let ocamlbuildflags = var_define ~short_desc:(fun () -> "OCamlbuild additional flags") "ocamlbuildflags" (fun () -> "") (** Fix special arguments depending on environment *) let fix_args args extra_argv = List.flatten [ if (os_type ()) = "Win32" then [ "-classic-display"; "-no-log"; "-no-links"; "-install-lib-dir"; (Filename.concat (standard_library ()) "ocamlbuild") ] else []; if not (bool_of_string (is_native ())) || (os_type ()) = "Win32" then [ "-byte-plugin" ] else []; args; if bool_of_string (debug ()) then ["-tag"; "debug"] else []; if bool_of_string (tests ()) then ["-tag"; "tests"] else []; if bool_of_string (profile ()) then ["-tag"; "profile"] else []; OASISString.nsplit (ocamlbuildflags ()) ' '; Array.to_list extra_argv; ] (** Run 'ocamlbuild -clean' if not already done *) let run_clean extra_argv = let extra_cli = String.concat " " (Array.to_list extra_argv) in (* Run if never called with these args *) if not (BaseLog.exists ocamlbuild_clean_ev extra_cli) then begin OASISExec.run ~ctxt:!BaseContext.default (ocamlbuild ()) (fix_args ["-clean"] extra_argv); BaseLog.register ocamlbuild_clean_ev extra_cli; at_exit (fun () -> try BaseLog.unregister ocamlbuild_clean_ev extra_cli with _ -> ()) end (** Run ocamlbuild, unregister all clean events *) let run_ocamlbuild args extra_argv = (* TODO: enforce that target in args must be UNIX encoded i.e. toto/index.html *) OASISExec.run ~ctxt:!BaseContext.default (ocamlbuild ()) (fix_args args extra_argv); (* Remove any clean event, we must run it again *) List.iter (fun (e, d) -> BaseLog.unregister e d) (BaseLog.filter [ocamlbuild_clean_ev]) (** Determine real build directory *) let build_dir extra_argv = let rec search_args dir = function | "-build-dir" :: dir :: tl -> search_args dir tl | _ :: tl -> search_args dir tl | [] -> dir in search_args "_build" (fix_args [] extra_argv) end module OCamlbuildPlugin = struct (* # 22 "src/plugins/ocamlbuild/OCamlbuildPlugin.ml" *) (** Build using ocamlbuild @author Sylvain Le Gall *) open OASISTypes open OASISGettext open OASISUtils open OASISString open BaseEnv open OCamlbuildCommon open BaseStandardVar open BaseMessage let cond_targets_hook = ref (fun lst -> lst) let build extra_args pkg argv = (* Return the filename in build directory *) let in_build_dir fn = Filename.concat (build_dir argv) fn in (* Return the unix filename in host build directory *) let in_build_dir_of_unix fn = in_build_dir (OASISHostPath.of_unix fn) in let cond_targets = List.fold_left (fun acc -> function | Library (cs, bs, lib) when var_choose bs.bs_build -> begin let evs, unix_files = BaseBuilt.of_library in_build_dir_of_unix (cs, bs, lib) in let tgts = List.flatten (List.filter (fun l -> l <> []) (List.map (List.filter (fun fn -> ends_with ~what:".cma" fn || ends_with ~what:".cmxs" fn || ends_with ~what:".cmxa" fn || ends_with ~what:(ext_lib ()) fn || ends_with ~what:(ext_dll ()) fn)) unix_files)) in match tgts with | _ :: _ -> (evs, tgts) :: acc | [] -> failwithf (f_ "No possible ocamlbuild targets for library %s") cs.cs_name end | Object (cs, bs, obj) when var_choose bs.bs_build -> begin let evs, unix_files = BaseBuilt.of_object in_build_dir_of_unix (cs, bs, obj) in let tgts = List.flatten (List.filter (fun l -> l <> []) (List.map (List.filter (fun fn -> ends_with ".cmo" fn || ends_with ".cmx" fn)) unix_files)) in match tgts with | _ :: _ -> (evs, tgts) :: acc | [] -> failwithf (f_ "No possible ocamlbuild targets for object %s") cs.cs_name end | Executable (cs, bs, exec) when var_choose bs.bs_build -> begin let evs, unix_exec_is, unix_dll_opt = BaseBuilt.of_executable in_build_dir_of_unix (cs, bs, exec) in let target ext = let unix_tgt = (OASISUnixPath.concat bs.bs_path (OASISUnixPath.chop_extension exec.exec_main_is))^ext in let evs = (* Fix evs, we want to use the unix_tgt, without copying *) List.map (function | BaseBuilt.BExec, nm, lst when nm = cs.cs_name -> BaseBuilt.BExec, nm, [[in_build_dir_of_unix unix_tgt]] | ev -> ev) evs in evs, [unix_tgt] in (* Add executable *) let acc = match bs.bs_compiled_object with | Native -> (target ".native") :: acc | Best when bool_of_string (is_native ()) -> (target ".native") :: acc | Byte | Best -> (target ".byte") :: acc in acc end | Library _ | Object _ | Executable _ | Test _ | SrcRepo _ | Flag _ | Doc _ -> acc) [] (* Keep the pkg.sections ordered *) (List.rev pkg.sections); in (* Check and register built files *) let check_and_register (bt, bnm, lst) = List.iter (fun fns -> if not (List.exists OASISFileUtil.file_exists_case fns) then failwithf (fn_ "Expected built file %s doesn't exist." "None of expected built files %s exists." (List.length fns)) (String.concat (s_ " or ") (List.map (Printf.sprintf "'%s'") fns))) lst; (BaseBuilt.register bt bnm lst) in (* Run the hook *) let cond_targets = !cond_targets_hook cond_targets in (* Run a list of target... *) run_ocamlbuild (List.flatten (List.map snd cond_targets) @ extra_args) argv; (* ... and register events *) List.iter check_and_register (List.flatten (List.map fst cond_targets)) let clean pkg extra_args = run_clean extra_args; List.iter (function | Library (cs, _, _) -> BaseBuilt.unregister BaseBuilt.BLib cs.cs_name | Executable (cs, _, _) -> BaseBuilt.unregister BaseBuilt.BExec cs.cs_name; BaseBuilt.unregister BaseBuilt.BExecLib cs.cs_name | _ -> ()) pkg.sections end module OCamlbuildDocPlugin = struct (* # 22 "src/plugins/ocamlbuild/OCamlbuildDocPlugin.ml" *) (* Create documentation using ocamlbuild .odocl files @author Sylvain Le Gall *) open OASISTypes open OASISGettext open OASISMessage open OCamlbuildCommon open BaseStandardVar type run_t = { extra_args: string list; run_path: unix_filename; } let doc_build run pkg (cs, doc) argv = let index_html = OASISUnixPath.make [ run.run_path; cs.cs_name^".docdir"; "index.html"; ] in let tgt_dir = OASISHostPath.make [ build_dir argv; OASISHostPath.of_unix run.run_path; cs.cs_name^".docdir"; ] in run_ocamlbuild (index_html :: run.extra_args) argv; List.iter (fun glb -> BaseBuilt.register BaseBuilt.BDoc cs.cs_name [OASISFileUtil.glob ~ctxt:!BaseContext.default (Filename.concat tgt_dir glb)]) ["*.html"; "*.css"] let doc_clean run pkg (cs, doc) argv = run_clean argv; BaseBuilt.unregister BaseBuilt.BDoc cs.cs_name end # 6651 "setup.ml" open OASISTypes;; let setup_t = { BaseSetup.configure = InternalConfigurePlugin.configure; build = OCamlbuildPlugin.build [ "-use-ocamlfind"; "-plugin-tags"; "'package(js-build-tools.ocamlbuild_goodies)'" ]; test = []; doc = []; install = InternalInstallPlugin.install; uninstall = InternalInstallPlugin.uninstall; clean = [OCamlbuildPlugin.clean]; clean_test = []; clean_doc = []; distclean = []; distclean_test = []; distclean_doc = []; package = { oasis_version = "0.4"; ocaml_version = Some (OASISVersion.VGreaterEqual "4.02.3"); findlib_version = Some (OASISVersion.VGreaterEqual "1.3.2"); alpha_features = ["ocamlbuild_more_args"]; beta_features = ["section_object"]; name = "ppx_sexp_conv"; version = "113.33.03"; license = OASISLicense.DEP5License (OASISLicense.DEP5Unit { OASISLicense.license = "Apache"; excption = None; version = OASISLicense.Version "2.0" }); license_file = Some "LICENSE.txt"; copyrights = [ "(C) 2015-2016 Jane Street Group LLC " ]; maintainers = ["Jane Street Group"; "LLC "]; authors = ["Jane Street Group"; "LLC "]; homepage = Some "https://github.com/janestreet/ppx_sexp_conv"; synopsis = "Generation of S-expression conversion functions from type definitions"; description = Some [ OASISText.Para "Part of the Jane Street's PPX rewriters collection." ]; categories = []; conf_type = (`Configure, "internal", Some "0.4"); conf_custom = { pre_command = [(OASISExpr.EBool true, None)]; post_command = [(OASISExpr.EBool true, None)] }; build_type = (`Build, "ocamlbuild", Some "0.4"); build_custom = { pre_command = [(OASISExpr.EBool true, None)]; post_command = [(OASISExpr.EBool true, None)] }; install_type = (`Install, "internal", Some "0.4"); install_custom = { pre_command = [(OASISExpr.EBool true, None)]; post_command = [(OASISExpr.EBool true, None)] }; uninstall_custom = { pre_command = [(OASISExpr.EBool true, None)]; post_command = [(OASISExpr.EBool true, None)] }; clean_custom = { pre_command = [(OASISExpr.EBool true, None)]; post_command = [(OASISExpr.EBool true, None)] }; distclean_custom = { pre_command = [(OASISExpr.EBool true, None)]; post_command = [(OASISExpr.EBool true, None)] }; files_ab = ["META.ab"]; sections = [ Library ({ cs_name = "ppx_sexp_conv_expander"; cs_data = PropList.Data.create (); cs_plugin_data = [] }, { bs_build = [(OASISExpr.EBool true, true)]; bs_install = [(OASISExpr.EBool true, true)]; bs_path = "expander"; bs_compiled_object = Best; bs_build_depends = [ FindlibPackage ("ppx_core", None); FindlibPackage ("ppx_tools.metaquot", None) ]; bs_build_tools = [ExternalTool "ocamlbuild"]; bs_c_sources = []; bs_data_files = []; bs_ccopt = [(OASISExpr.EBool true, [])]; bs_cclib = [(OASISExpr.EBool true, [])]; bs_dlllib = [(OASISExpr.EBool true, [])]; bs_dllpath = [(OASISExpr.EBool true, [])]; bs_byteopt = [(OASISExpr.EBool true, [])]; bs_nativeopt = [(OASISExpr.EBool true, [])] }, { lib_modules = ["Ppx_sexp_conv_expander"]; lib_pack = false; lib_internal_modules = []; lib_findlib_parent = None; lib_findlib_name = None; lib_findlib_containers = [] }); Library ({ cs_name = "ppx_sexp_conv"; cs_data = PropList.Data.create (); cs_plugin_data = [] }, { bs_build = [(OASISExpr.EBool true, true)]; bs_install = [(OASISExpr.EBool true, true)]; bs_path = "src"; bs_compiled_object = Best; bs_build_depends = [ FindlibPackage ("ppx_core", None); InternalLibrary "ppx_sexp_conv_expander"; FindlibPackage ("ppx_type_conv", None) ]; bs_build_tools = [ExternalTool "ocamlbuild"]; bs_c_sources = []; bs_data_files = []; bs_ccopt = [(OASISExpr.EBool true, [])]; bs_cclib = [(OASISExpr.EBool true, [])]; bs_dlllib = [(OASISExpr.EBool true, [])]; bs_dllpath = [(OASISExpr.EBool true, [])]; bs_byteopt = [(OASISExpr.EBool true, [])]; bs_nativeopt = [(OASISExpr.EBool true, [])] }, { lib_modules = ["Ppx_sexp_conv"]; lib_pack = false; lib_internal_modules = []; lib_findlib_parent = None; lib_findlib_name = None; lib_findlib_containers = [] }) ]; plugins = [ (`Extra, "StdFiles", Some "0.3"); (`Extra, "DevFiles", Some "0.3") ]; disable_oasis_section = []; schema_data = PropList.Data.create (); plugin_data = [] }; oasis_fn = Some "_oasis"; oasis_version = "0.4.5"; oasis_digest = Some "\177\200\250\192\211\144`\029\246\245\017\207M\239'B"; oasis_exec = None; oasis_setup_args = []; setup_update = false };; let setup () = BaseSetup.setup setup_t;; # 6836 "setup.ml" (* OASIS_STOP *) let () = setup () ppx_sexp_conv-113.33.03/descr0000664002755601004200000000017212710355760015117 0ustar jdiminotechGeneration of S-expression conversion functions from type definitions Part of the Jane Street's PPX rewriters collection. ppx_sexp_conv-113.33.03/.gitignore0000664002755601004200000000010212710355760016055 0ustar jdiminotech_build/ /setup.data /setup.log /*.exe /*.docdir /*.native /*.byte ppx_sexp_conv-113.33.03/README.org0000664002755601004200000002312512710355760015545 0ustar jdiminotech* [@@deriving sexp] =ppx_sexp_conv= is a PPX syntax extension that generates code for converting OCaml types to and from s-expressions, as defined in the [[https://github.com/janestreet/sexplib][=sexplib=]] library. S-expressions are defined by the following type: #+begin_src ocaml type sexp = Atom of string | List of sexp list #+end_src and are rendered as parenthesized lists of strings, /e.g./ =(This (is an) (s expression))=. =ppx_sexp_conv= fits into the [[https://github.com/whitequark/ppx_deriving][=ppx_deriving=]] framework, so you can invoke it the same way you invoke any other deriving plug-in. Thus, we can write #+begin_src ocaml type int_pair = (int * int) [@@deriving sexp] #+end_src to get two values defined automatically, =sexp_of_int_pair= and =int_pair_of_sexp=. If we only want one direction, we can write one of the following. #+begin_src ocaml type int_pair = (int * int) [@@deriving sexp_of] type int_pair = (int * int) [@@deriving of_sexp] #+end_src These sexp-converters depend on having a set of converters for basic values (/e.g./, =int_of_sexp=) already in scope. This can be done by writing: #+begin_src ocaml open Sexplib.Std #+end_src If you're using [[https://github.com/janestreet/core][=Core=]] or [[https://github.com/janestreet/core_kernel][=Core_kernel=]], you can get the same effect with =open Core.Std= or =open Core_kernel.Std=. It's also possible to construct converters based on type expressions, /i.e./: #+begin_src ocaml [%sexp_of: (int * string) list] [1,"one"; 2,"two"] |> Sexp.to_string;; => "((1 one) (2 two))" [%sexp_of: (int * string) list] [1,"one"; 2,"two"] |> [%of_sexp: (int * string) list];; => [1,"one"; 2,"two"] #+end_src For =%sexp_of=, we can also omit the conversion of some types by putting underscores for that type name. #+begin_src ocaml [%sexp_of: (int * _) list] [1,"one"; 2,"two"] |> Sexp.to_string;; => "((1 _)(2 _))" #+end_src ** Conversion rules In the following, we'll review the serialization rules for different OCaml types. *** Basic types Basic types are represented as atoms. For numbers like =int=, =int32=, =int64=, =float=, the string in the atom is what is accepted the standard ocaml functions =int_of_string=, =Int32.of_string=, etc. For the types =char= or =string=, the string in the atom is respectively a one character string or the string itself. *** Lists and arrays OCaml-lists and arrays are represented as s-expression lists. *** Tuples and unit OCaml tuples are treated as lists of values in the same order as in the tuple. The type =unit= is treated like a 0-tuple. /e.g./: #+begin_src ocaml (3.14, "foo", "bar bla", 27) => (3.14 foo "bar bla" 27) #+end_src *** Options With options, =None= is treated as a zero-element list, and =Some= is treated as a singleton list, as shown below. #+begin_src ocaml None => () Some value => (value) #+end_src We also support reading options following the ordinary rules for variants /i.e./: #+begin_src ocaml None => None Some value => (Some value) #+end_src The rules for variants are described below. *** Records Records are represented as lists of lists, where each inner list is a key-value pair. Each pair consists of the name of the record field (first element), and its value (second element). /e.g./: #+begin_src ocaml { foo = (3,4); bar = "some string"; } => ((foo (3 4)) (bar "some string")) #+end_src Type specifications of records allow the use of a special type =sexp_option= which indicates that a record field should be optional. /e.g./: #+begin_src ocaml type t = { x : int option; y : int sexp_option; } with sexp #+end_src The type =sexp_option= is equivalent to ordinary options, but is treated specially by the code generator. The following examples show how this works. #+begin_src ocaml { x = Some 1; y = Some 2; } => ((x (1)) (y 2)) { x = None ; y = None; } => ((x ())) #+end_src Note that, when present, on optional value is represented as the bare value, rather than explicitly as an option. The types =sexp_list= and =sexp_array= can be used in ways similar to the type =sexp_option=. They assume the empty list and empty array respectively as default values. **** Defaults More complex default values can be specified explicitly using several constructs, /e.g./: #+begin_src ocaml let z_test v = v > 42 type t = { x : int [@default 42]; y : int [@default 3] [@sexp_drop_default]; z : int [@default 3] [@sexp_drop_if fun x -> x = 3]; } [@@deriving sexp] #+end_src The =@default= annotation lets one specify a default value to be selected if the field is not specified, when converting from an s-expression. The =@sexp_drop_default= annotation implies that the field will be dropped when generating the s-expression if the value being serialized is equal to the default according to polymorphic equality. Finally, =@sexp_drop_if= is like =@sexp_drop_default=, except that it lets you specify the condition under which the field is dropped. *** Variants Constant constructors in variants are represented as strings. Constructors with arguments are represented as lists, the first element being the constructor name, the rest being its arguments. Constructors may also be started in lowercase in S-expressions, but will always be converted to uppercase when converting from OCaml values. For example: #+begin_src ocaml type t = A | B of int * float * t with sexp B (42, 3.14, B (-1, 2.72, A)) => (B 42 3.14 (B -1 2.72 A)) #+end_src The above example also demonstrates recursion in data structures. *** Polymorphic variants Polymorphic variants behave almost the same as ordinary variants. The notable difference is that polymorphic variant constructors must always start with an either lower- or uppercase character, matching the way it was specified in the type definition. This is because OCaml distinguishes between upper and lowercase variant constructors. Note that type specifications containing unions of variant types are also supported by the S-expression converter, for example as in: #+begin_src ocaml type ab = [ `A | `B ] [@@deriving sexp] type cd = [ `C | `D ] [@@deriving sexp] type abcd = [ ab | cd ] [@@deriving sexp] #+end_src *** Polymorphic values There is nothing special about polymorphic values as long as there are conversion functions for the type parameters. /e.g./: #+begin_src ocaml type 'a t = A | B of 'a [@@deriving sexp] type foo = int t [@@deriving sexp] #+end_src In the above case the conversion functions will behave as if =foo= had been defined as a monomorphic version of =t= with ='a= replaced by =int= on the right hand side. If a data structure is indeed polymorphic and you want to convert it, you will have to supply the conversion functions for the type parameters at runtime. If you wanted to convert a value of type ='a t= as in the above example, you would have to write something like this: #+begin_src ocaml sexp_of_t sexp_of_a v #+end_src where =sexp_of_a=, which may also be named differently in this particular case, is a function that converts values of type ='a= to an S-expression. Types with more than one parameter require passing conversion functions for those parameters in the order of their appearance on the left hand side of the type definition. *** Opaque values Opaque values are ones for which we do not want to perform conversions. This may be, because we do not have S-expression converters for them, or because we do not want to apply them in a particular type context. /e.g./ to hide large, unimportant parts of configurations. To prevent the preprocessor from generating calls to converters, simply apply the qualifier =sexp_opaque= as if it were a type constructor, /e.g./: #+begin_src ocaml type foo = int * stuff sexp_opaque [@@deriving sexp] #+end_src Thus, there is no need to specify converters for type =stuff=, and if there are any, they will not be used in this particular context. Needless to say, it is not possible to convert such an S-expression back to the original value. Here is an example conversion: #+begin_src ocaml (42, some_stuff) => (42 ) #+end_src *** Exceptions S-expression converters for exceptions can be automatically registered. #+begin_src ocaml module M = struct exception Foo of int [@@deriving sexp] end #+end_src Such exceptions will be translated in a similar way as sum types, but their constructor will be prefixed with the fully qualified module path (here: =M.Foo=) so as to be able to discriminate between them without problems. The user can then easily convert an exception matching the above one to an S-expression using =sexp_of_exn=. User-defined conversion functions can be registered, too, by calling =add_exn_converter=. This should make it very convenient for users to catch arbitrary exceptions escaping their program and pretty-printing them, including all arguments, as S-expressions. The library already contains mappings for all known exceptions that can escape functions in the OCaml standard library. *** Hash tables The Stdlib's Hash tables, which are abstract values in OCaml, are represented as association lists, /i.e./ lists of key-value pairs, /e.g./: #+begin_src scheme ((foo 42) (bar 3)) #+end_src Reading in the above S-expression as hash table mapping strings to integers (=(string, int) Hashtbl.t=) will map =foo= to =42= and =bar= to =3=. Note that the order of elements in the list may matter, because the OCaml-implementation of hash tables keeps duplicates. Bindings will be inserted into the hash table in the order of appearance. Therefore, the last binding of a key will be the "visible" one, the others are "hidden". See the OCaml documentation on hash tables for details. ppx_sexp_conv-113.33.03/CHANGES.md0000664002755601004200000000312312710355760015465 0ustar jdiminotech## 113.33.00 - Clean up the documentation for sexplib, modernizing it to include `ppx_sexp_conv`, and breaking up the documentation between sexplib and `ppx_sexp_conv`. Also changed the formatting to use org-mode, so it will render properly on github. Markdown doesn't render well by default, unless you use quite different conventions about linebeaks. ## 113.24.00 - Trying to improve the tests in ppx\_sexp\_conv because they are a mess. At least all tests are automatic now. And more things are tested like the sexpification of exceptions. - Update to follow `Type_conv` and `Ppx_core` evolution. - Make ppx\_sexp\_conv correctly handle aliases to polymorphic variants: type t = ` `A ` `@@deriving sexp` type u = t `@@deriving sexp` type v = ` u | `B ` `@@deriving sexp` Before, `v_of_sexp` would never manage to read `B. This problem is now fixed if you use `sexp_poly` on `u` instead of `sexp`, and if you don't, you get an "unbound value __u_of_sexp__". People should use `sexp_poly` when they have a polymorphic variant type that is not syntactically a polymorphic variant, but in practice it's simpler to replace `sexp` by `sexp_poly` when faced with the error above. The need for `sexp_poly` should happen only in one new case: an implementation says `type u = t `@@deriving sexp`` but the interface says `type u = ``A` `@@deriving sexp``. (the old case where it was already needed is when you have an interface that says `type u = t `@@deriving sexp`` and in some other implementation you try to say `type t = ` That_module.t | `A ` `@@deriving sexp``). ppx_sexp_conv-113.33.03/Makefile0000664002755601004200000000324412710357125015534 0ustar jdiminotech# Generic Makefile for oasis project SETUP := setup.exe NAME := ppx_sexp_conv PREFIX = $(shell grep ^prefix= setup.data | cut -d\" -f 2) # Default rule default: build setup.exe: setup.ml ocamlopt.opt -o $@ $< || ocamlopt -o $@ $< || ocamlc -o $@ $< for f in setup.*; do [ $$f = $@ -o $$f = setup.ml ] || rm -f $$f; done build: $(SETUP) setup.data ./$(SETUP) -build $(BUILDFLAGS) $(MAKE) $(NAME).install doc: $(SETUP) setup.data build ./$(SETUP) -doc $(DOCFLAGS) test: $(SETUP) setup.data build ./$(SETUP) -test $(TESTFLAGS) all: $(SETUP) ./$(SETUP) -all $(ALLFLAGS) $(MAKE) $(NAME).install $(NAME).install: install.ml setup.log setup.data ocaml -I "$(OCAML_TOPLEVEL_PATH)" install.ml install: $(NAME).install opam-installer -i --prefix $(PREFIX) $(NAME).install uninstall: $(NAME).install opam-installer -u --prefix $(PREFIX) $(NAME).install reinstall: $(NAME).install opam-installer -u --prefix $(PREFIX) $(NAME).install &> /dev/null || true opam-installer -i --prefix $(PREFIX) $(NAME).install bin.tar.gz: $(NAME).install rm -rf _install mkdir _install opam-installer -i --prefix _install $(NAME).install tar czf bin.tar.gz -C _install . rm -rf _install bin.lzo: $(NAME).install rm -rf _install mkdir _install opam-installer -i --prefix _install $(NAME).install cd _install && lzop -1 -P -o ../bin.lzo `find . -type f` rm -rf _install clean: $(SETUP) ./$(SETUP) -clean $(CLEANFLAGS) distclean: $(SETUP) ./$(SETUP) -distclean $(DISTCLEANFLAGS) configure: $(SETUP) ./$(SETUP) -configure $(CONFIGUREFLAGS) setup.data: $(SETUP) ./$(SETUP) -configure $(CONFIGUREFLAGS) .PHONY: default build doc test all install uninstall reinstall clean distclean configure ppx_sexp_conv-113.33.03/LICENSE.txt0000664002755601004200000002613612710355760015727 0ustar jdiminotech Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ppx_sexp_conv-113.33.03/_oasis0000664002755601004200000000255412710355760015302 0ustar jdiminotechOASISFormat: 0.4 OCamlVersion: >= 4.02.3 FindlibVersion: >= 1.3.2 Name: ppx_sexp_conv Version: 113.33.03 Synopsis: Generation of S-expression conversion functions from type definitions Authors: Jane Street Group, LLC Copyrights: (C) 2015-2016 Jane Street Group LLC Maintainers: Jane Street Group, LLC License: Apache-2.0 LicenseFile: LICENSE.txt Homepage: https://github.com/janestreet/ppx_sexp_conv Plugins: StdFiles (0.3), DevFiles (0.3) XStdFilesAUTHORS: false XStdFilesREADME: false BuildTools: ocamlbuild BetaFeatures: section_object AlphaFeatures: ocamlbuild_more_args XOCamlbuildPluginTags: package(js-build-tools.ocamlbuild_goodies) FilesAB: META.ab Description: Part of the Jane Street's PPX rewriters collection. Library ppx_sexp_conv Path: src Pack: false Modules: Ppx_sexp_conv BuildDepends: ppx_core, ppx_sexp_conv_expander, ppx_type_conv Library ppx_sexp_conv_expander Path: expander Pack: false Modules: Ppx_sexp_conv_expander BuildDepends: ppx_core, ppx_tools.metaquot ppx_sexp_conv-113.33.03/INRIA-DISCLAIMER.txt0000664002755601004200000000133212710355760017110 0ustar jdiminotechTHIS SOFTWARE IS PROVIDED BY INRIA AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL INRIA OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ppx_sexp_conv-113.33.03/THIRD-PARTY.txt0000664002755601004200000000136012710355760016404 0ustar jdiminotechThe repository contains 3rd-party code in the following locations and under the following licenses: - type_conv, sexplib and bin_prot: based on Tywith, by Martin Sandin. License can be found in base/sexplib/LICENSE-Tywith.txt, base/type_conv/LICENSE-Tywith.txt, and base/bin_prot/LICENSE-Tywith.txt. - Core's implementation of union-find: based on an implementation by Henry Matthew Fluet, Suresh Jagannathan, and Stephen Weeks. License can be found in base/core/MLton-license. - Various Core libraries are based on INRIA's OCaml distribution. Relicensed under Apache 2.0, as permitted under the Caml License for Consortium members: http://caml.inria.fr/consortium/license.en.html See also the disclaimer INRIA-DISCLAIMER.txt. ppx_sexp_conv-113.33.03/opam0000664002755601004200000000113712710357125014752 0ustar jdiminotechopam-version: "1.2" maintainer: "opensource@janestreet.com" authors: ["Jane Street Group, LLC "] homepage: "https://github.com/janestreet/ppx_sexp_conv" bug-reports: "https://github.com/janestreet/ppx_sexp_conv/issues" dev-repo: "https://github.com/janestreet/ppx_sexp_conv.git" license: "Apache-2.0" build: [ ["./configure" "--prefix" prefix] [make] ] depends: [ "ocamlbuild" {build} "ocamlfind" {build & >= "1.3.2"} "js-build-tools" {build} "ppx_core" "ppx_tools" {>= "0.99.3"} "ppx_type_conv" "sexplib" ] available: [ ocaml-version = "4.02.3" ] ppx_sexp_conv-113.33.03/META.ab0000664002755601004200000000265112710355760015132 0ustar jdiminotechversion = "$(pkg_version)" description = "Generation of S-expression conversion functions from type definitions" requires(-ppx_driver) = "ppx_core.for_ppx_deriving ppx_sexp_conv.expander.for_ppx_deriving ppx_type_conv.for_ppx_deriving sexplib" requires(ppx_driver) = "ppx_core ppx_sexp_conv.expander ppx_type_conv" requires(ppx_driver,toploop) += "sexplib" archive(ppx_driver, byte ) = "ppx_sexp_conv.cma" archive(ppx_driver, native) = "ppx_sexp_conv.cmxa" plugin(ppx_driver, byte ) = "ppx_sexp_conv.cma" plugin(ppx_driver, native) = "ppx_sexp_conv.cmxs" exists_if = "ppx_sexp_conv.cma" ppxopt(-ppx_driver,-custom_ppx) = "ppx_deriving,./ppx_sexp_conv.cma" package "expander" ( version = "$(pkg_version)" description = "Expander for ppx_sexp_conv" requires = "ppx_core" archive(byte ) = "ppx_sexp_conv_expander.cma" archive(native) = "ppx_sexp_conv_expander.cmxa" plugin(byte ) = "ppx_sexp_conv_expander.cma" plugin(native) = "ppx_sexp_conv_expander.cmxs" exists_if = "ppx_sexp_conv_expander.cma" # Until this is released: https://github.com/whitequark/ppx_deriving/pull/95 package "for_ppx_deriving" ( description = "Don't use this directly" error(ppx_driver) = "Cannot use ppx_sexp_conv.expander.for_ppx_deriving when ppx_driver is set" requires = "ppx_core.for_ppx_deriving ppx_deriving" exists_if = "ppx_sexp_conv_expander.cma" ppxopt(-custom_ppx) = "ppx_deriving,./ppx_sexp_conv_expander.cma" ) ) ppx_sexp_conv-113.33.03/test/0000775002755601004200000000000012710355760015053 5ustar jdiminotechppx_sexp_conv-113.33.03/test/ppx_sexp_test.mli0000664002755601004200000000000012710355760020451 0ustar jdiminotechppx_sexp_conv-113.33.03/test/io_test.ml0000664002755601004200000000224712710355760017060 0ustar jdiminotechopen Sexplib let () = let orig_sexps = Random.init 10; let a = Array.init 5 (fun i -> Array.init 10 (fun j -> String.init (i + j) (fun k -> Char.chr (Char.code 'a' + k)))) in let open Sexplib.Conv in match [%sexp_of: string array array] a with | List l -> l | Atom _ -> assert false in let hum_file = Filename.temp_file "hum" ".sexp" in let hum_oc = open_out hum_file in let hum_ppf = Format.formatter_of_out_channel hum_oc in List.iter (fun sexp -> Format.fprintf hum_ppf "%a@\n" Sexp.pp_hum sexp) orig_sexps; Format.pp_print_flush hum_ppf (); close_out hum_oc; let mach_file = Filename.temp_file "mach" ".sexp" in let mach_oc = open_out mach_file in List.iter (fun sexp -> Printf.fprintf mach_oc "%a\n" Sexp.output_mach sexp) orig_sexps; close_out mach_oc; let hum_ic = open_in hum_file in let hum_sexps = Sexp.input_sexps hum_ic in close_in hum_ic; assert (hum_sexps = orig_sexps); Sys.remove hum_file; let mach_ic = open_in mach_file in let mach_sexps = Sexp.input_sexps mach_ic in close_in mach_ic; assert (mach_sexps = orig_sexps); Sys.remove mach_file; ;; ppx_sexp_conv-113.33.03/test/lib/0000775002755601004200000000000012710355760015621 5ustar jdiminotechppx_sexp_conv-113.33.03/test/lib/conv_test.ml0000664002755601004200000000357512710355760020171 0ustar jdiminotechopen Sexplib.Conv module Exceptions = struct let check_sexp exn string = match sexp_of_exn_opt exn with | None -> raise exn | Some sexp -> let sexp_as_string = Sexplib.Sexp.to_string sexp in if sexp_as_string <> string then failwith sexp_as_string (* first global exceptions, checking different arities since they don't have the same representation *) exception Arg0 [@@deriving sexp] exception Arg1 of int [@@deriving sexp] exception Arg2 of int * int [@@deriving sexp] let%test_unit _ = check_sexp Arg0 "conv_test.ml.Exceptions.Arg0" let%test_unit _ = check_sexp (Arg1 1) "(conv_test.ml.Exceptions.Arg1 1)" let%test_unit _ = check_sexp (Arg2 (2, 3)) "(conv_test.ml.Exceptions.Arg2 2 3)" (* now local exceptions *) let exn (type a) a sexp_of_a = let module M = struct exception E of a [@@deriving sexp] end in M.E a let%test_unit "incompatible exceptions with the same name" = let e_int = exn 1 sexp_of_int in let e_string = exn "a" sexp_of_string in check_sexp e_int "(conv_test.ml.Exceptions.E 1)"; check_sexp e_string "(conv_test.ml.Exceptions.E a)" let copy (type a) (e : a) : a = Obj.obj (Obj.dup (Obj.repr e)) let%test "sexp converters are finalized properly for local exceptions" = let e = exn 2.5 sexp_of_float in let copy_of_e = copy e in let e_finalized = ref false in let ref_for_copy_of_e = ref None in Gc.finalise (fun _ -> e_finalized := true) e; Gc.finalise (fun e -> ref_for_copy_of_e := Some e) copy_of_e; check_sexp e "(conv_test.ml.Exceptions.E 2.5)"; check_sexp copy_of_e "(conv_test.ml.Exceptions.E 2.5)"; Gc.compact (); assert !e_finalized; check_sexp copy_of_e "(conv_test.ml.Exceptions.E 2.5)"; Gc.compact (); match !ref_for_copy_of_e with | None -> failwith "finalizer should have run" | Some e -> sexp_of_exn_opt e = None end ppx_sexp_conv-113.33.03/test/path_test.ml0000664002755601004200000000201112710355760017372 0ustar jdiminotechopen Sexplib open Conv type foo = A | B of int * float [@@deriving sexp] type 'a t = { x : foo; foo : int; bar : (float * string) list option; } [@@deriving sexp] type u = { t : int t } [@@deriving sexp] let () = let t = { x = B (42, 3.1) ; foo = 3 ; bar = Some [(3.1, "foo")]; } in let u = { t } in let u_sexp = sexp_of_u u in assert (Sexp.to_string u_sexp = "((t((x(B 42 3.1))(foo 3)(bar(((3.1 foo)))))))"); let path_str = ".[0].[1]" in let path = Path.parse path_str in let subst, el = Path.subst_path u_sexp path in assert (Sexp.to_string el = "((x(B 42 3.1))(foo 3)(bar(((3.1 foo)))))"); let dumb_sexp = subst (Atom "SUBST1") in assert (Sexp.to_string dumb_sexp = "((t SUBST1))"); let path_str = ".t.x.B[1]" in let path = Path.parse path_str in let subst, el = Path.subst_path u_sexp path in assert (Sexp.to_string el = "3.1"); let u_sexp = subst (Atom "SUBST2") in assert (Sexp.to_string u_sexp = "((t((x(B 42 SUBST2))(foo 3)(bar(((3.1 foo)))))))"); ;; ppx_sexp_conv-113.33.03/test/test.sexp0000664002755601004200000000065612710355760016742 0ustar jdiminotech(this is a list) (this is another list and (this is a nested list)) ( "\ This is a multi-line \ string with embedded newlines." "This string contains decimal \255, hex \xff codes, \ and other \\ \n escapes." A# # ## #x| ) ; Line comment #; ( S-expression comment ) #| #| Nested |# block comment "|#" |# #| "" |# #| ""|# #|"" |# #|""|# #| "asdf" "asdf" |# (something #| ; |# () "something else") ppx_sexp_conv-113.33.03/test/newlines.ml0000664002755601004200000000557512710355760017245 0ustar jdiminotechopen StdLabels open Sexplib let windowsify_newlines str = let b = Buffer.create (String.length str * 2) in for i = 0 to String.length str - 1; do match str.[i] with | '\n' -> Buffer.add_string b "\r\n" | c -> Buffer.add_char b c done; Buffer.contents b let () = List.iter [ "simple atom", Sexp.Atom "line1"; "one trailing newline", Sexp.Atom "line1\n"; "two lines", Sexp.Atom "line1\nline2"; "two lines and trailing newline", Sexp.Atom "line1\nline2\n"; "two lines, windows style", Sexp.Atom "line1\r\nline2"; "two lines and trailing windows style", Sexp.Atom "line1\r\nline2\r\n"; "two lines inside of parens", Sexp.of_string "(\"line1\nline2\")"; "many lines and indentation in the atom", Sexp.Atom "line1\n line2\n line3\n line4\n"; "indentation with tabs in the atom", Sexp.Atom "line1\n\tline2\n\t\tline3\n\t\t\tline4\n"; "trailing whitespace", Sexp.List [Sexp.List [Sexp.Atom "line1 \n line3 \n "]]; "catalog snapshot", Sexp.Atom " cancel-buy\n | cancel-sell\n | | local-buy\n | | | local-cancel-buy\n | | | | local-cancel-sell\n | | | | | local-sell\nINDEX buy | | | | | | sell\n| | | | | | | | |\ntest_sym1 10. 10. 9.\ntest_sym3 \n"; ] ~f:(fun (title, sexp) -> (* My understanding of newlines on windows is that in memory, a newline is a \n, but when writing to a file with a file handler open in text mode, all the \n are replaced with \r\n. Of course the conversion is undone when reading with a file handler open in text mode. If saving \n in text-mode and reading it in binary mode, we would receive \r\n back. I am testing that serializing + writing in text mode + reading in binary mode + deserializing is the identity (because it was before this newline printing stuff), and all the other cases should just work. *) let reparsed = Sexp.of_string (Sexp.to_string_hum sexp) in let reparsed_after_windows_fiddling = Sexp.of_string (windowsify_newlines (Sexp.to_string_hum sexp)) in let reparsing_result = if reparsed <> sexp then Printf.sprintf "to_string_hum + of_string + to_mach is NOT the identity:\n%s\n" (Sexp.to_string_mach reparsed) else "" in let reparsing_after_windows_fiddling_result = if reparsed_after_windows_fiddling <> sexp then Printf.sprintf "to_string_hum + windowsify + of_string + to_mach is NOT the identity:\n%s\n" (Sexp.to_string_mach reparsed_after_windows_fiddling) else "" in Printf.printf "------ %s ------\nmach:\n%s\nhum:\n%s\n%s%s\n" title (Sexp.to_string_mach sexp) (Sexp.to_string_hum sexp) reparsing_result reparsing_after_windows_fiddling_result ) ppx_sexp_conv-113.33.03/test/nonrec_test.ml0000664002755601004200000000413512710355760017733 0ustar jdiminotechopen Sexplib open Conv type t = float [@@deriving sexp] module M : sig type t = float list [@@deriving sexp] end = struct type nonrec t = t list [@@deriving sexp] end type 'a u = 'a [@@deriving sexp] module M2 : sig type 'a u = 'a list [@@deriving sexp] end = struct type nonrec 'a u = 'a u list [@@deriving sexp] end type 'a v = 'a w and 'a w = A of 'a v [@@deriving sexp] type 'a v_ = 'a v [@@deriving sexp] type 'a w_ = 'a w [@@deriving sexp] module M3 : sig type 'a v = 'a w_ [@@deriving sexp] type 'a w = 'a v_ [@@deriving sexp] end = struct type nonrec 'a v = 'a w and 'a w = 'a v [@@deriving sexp] end type t0 = A of t0 [@@deriving sexp] module B : sig type nonrec t0 = t0 [@@deriving sexp] end = struct type nonrec t0 = t0 = A of t0 [@@deriving sexp] end type t1 = A of t2 and t2 = B of t1 [@@deriving sexp] module C : sig type nonrec t1 = t1 [@@deriving sexp] type nonrec t2 = t2 [@@deriving sexp] end = struct type nonrec t1 = t1 = A of t2 and t2 = t2 = B of t1 [@@deriving sexp] end type 'a v1 = A of 'a v2 and 'a v2 = B of 'a v1 [@@deriving sexp] module D : sig type nonrec 'a v1 = 'a v1 [@@deriving sexp] type nonrec 'a v2 = 'a v2 [@@deriving sexp] end = struct type nonrec 'a v1 = 'a v1 = A of 'a v2 and 'a v2 = 'a v2 = B of 'a v1 [@@deriving sexp] end type +'a w1 module E = struct type nonrec +'a w1 = 'a w1 end type 'a y1 = A of 'a y2 and 'a y2 = B of 'a y1 module F : sig type nonrec 'a y2 = B of 'a y1 type nonrec 'a y1 = 'a y1 end = struct type nonrec 'a y1 = 'a y1 = A of 'a y2 and 'a y2 = B of 'a y1 end type z1 = A of z1 module G : sig module A : sig type z2 = A of z2 end module B : sig type z2 = A of z2 end module C : sig type z2 = A of z2 end end = struct type z2 = z1 = A of z1 module A = struct type nonrec z2 = z1 = A of z2 end module B = struct type nonrec z2 = z2 = A of z2 end module C = struct type nonrec z2 = z2 = A of z1 end end type ('a, 'b) zz = A of 'a * 'b module H = struct type nonrec ('a, 'b) zz = ('a, 'b) zz = A of 'a * 'b end module I = struct type nonrec 'a zz = ('a, 'a) zz end ppx_sexp_conv-113.33.03/test/newlines.expected0000664002755601004200000000346312710355760020430 0ustar jdiminotech------ simple atom ------ mach: line1 hum: line1 ------ one trailing newline ------ mach: "line1\n" hum: "line1\n" ------ two lines ------ mach: "line1\nline2" hum: "line1\ \nline2" ------ two lines and trailing newline ------ mach: "line1\nline2\n" hum: "line1\ \nline2\ \n" ------ two lines, windows style ------ mach: "line1\r\nline2" hum: "line1\r\ \nline2" ------ two lines and trailing windows style ------ mach: "line1\r\nline2\r\n" hum: "line1\r\ \nline2\r\ \n" ------ two lines inside of parens ------ mach: ("line1\nline2") hum: ( "line1\ \nline2") ------ many lines and indentation in the atom ------ mach: "line1\n line2\n line3\n line4\n" hum: "line1\ \n line2\ \n line3\ \n line4\ \n" ------ indentation with tabs in the atom ------ mach: "line1\n\tline2\n\t\tline3\n\t\t\tline4\n" hum: "line1\ \n\tline2\ \n\t\tline3\ \n\t\t\tline4\ \n" ------ trailing whitespace ------ mach: (("line1 \n line3 \n ")) hum: (( "line1 \ \n line3 \ \n ")) ------ catalog snapshot ------ mach: " cancel-buy\n | cancel-sell\n | | local-buy\n | | | local-cancel-buy\n | | | | local-cancel-sell\n | | | | | local-sell\nINDEX buy | | | | | | sell\n| | | | | | | | |\ntest_sym1 10. 10. 9.\ntest_sym3 \n" hum: " cancel-buy\ \n | cancel-sell\ \n | | local-buy\ \n | | | local-cancel-buy\ \n | | | | local-cancel-sell\ \n | | | | | local-sell\ \nINDEX buy | | | | | | sell\ \n| | | | | | | | |\ \ntest_sym1 10. 10. 9.\ \ntest_sym3 \ \n" ppx_sexp_conv-113.33.03/test/parser_test.ml0000664002755601004200000002510012710355760017736 0ustar jdiminotechopen Sexplib open Test_common (* TODO: assert that the positions are ok as well *) let sexp_of_layout_sexp = Sexp.With_layout.sexp_of_t_or_comment let sexps_of_layout_sexps l = List.map sexp_of_layout_sexp l let sexp_of_layout_sexps_or_something sexps_with_layout = match Sexp.With_layout.Forget.t_or_comments sexps_with_layout with | [s] -> s | [] | _ :: _ :: _ as sexps -> (* this is an error, but returning something is more effective for debug *) Sexp.List ( Sexp.List sexps :: Sexp.List (sexps_of_layout_sexps sexps_with_layout) :: [] ) let parsers = [ Sexp.of_string, "cont"; (fun s -> (* feeding the characters to the parse function one by one to make sure the cont_state machinery is working fine *) let pos = 0 in match Sexp.parse ~len:1 s with | Sexp.Done (t, _) -> t | Sexp.Cont (cont_state, parse_fun) -> let rec aux parse_fun pos = assert (pos < String.length s); match parse_fun ~pos ~len:1 s with | Sexp.Done (t, _) -> if pos + 1 = String.length s then t else failwith "Should have reached the end1" | Sexp.Cont (cont_state, parse_fun) -> aux_cont pos cont_state parse_fun and aux_cont pos cont_state parse_fun = if pos + 1 = String.length s then match cont_state with | Sexp.Cont_state.Parsing_atom -> begin match parse_fun ~pos:0 ~len:1 " " with | Sexp.Done (t, _) -> t | Sexp.Cont _ -> failwith "Should have reached the end2" end | Sexp.Cont_state.Parsing_sexp_comment | Sexp.Cont_state.Parsing_block_comment | Sexp.Cont_state.Parsing_whitespace -> failwith "incomplete" | Sexp.Cont_state.Parsing_list -> failwith "Should have reached the end3" else aux parse_fun (pos + 1) in aux_cont pos cont_state parse_fun ), "cont-incremental"; (fun s -> Sexp.scan_sexp (Lexing.from_string s)), "ocamllex"; (fun s -> Sexp.Annotated.get_sexp (Sexp.Annotated.of_string s)), "annot"; (fun s -> let sexps_with_layout = Sexp.With_layout.Parser.sexps Sexp.With_layout.Lexer.main (Lexing.from_string s) in sexp_of_layout_sexps_or_something sexps_with_layout ), "layout-sexps"; (fun s -> let parse = let lexbuf = Lexing.from_string s in fun () -> Sexp.With_layout.Parser.sexp_opt Sexp.With_layout.Lexer.main lexbuf in let rec aux acc = match parse () with | None -> List.rev acc | Some sexp -> aux (sexp :: acc) in sexp_of_layout_sexps_or_something (aux []) ), "layout-sexp-opt"; ] (* no idea why we can't read multiple sexps from a string directly *) let put_string_in_channel s f = let file, out_channel = Filename.open_temp_file "sexplib_test" "" in output_string out_channel s; close_out out_channel; let in_channel = open_in file in let v = try `Value (f in_channel) with exn -> `Exn exn in close_in in_channel; Sys.remove file; match v with | `Value v -> v | `Exn exn -> raise exn let list_parsers = [ (fun s -> Sexp.List (put_string_in_channel s Sexp.input_sexps)), "cont"; (fun s -> Sexp.List (Sexp.scan_sexps (Lexing.from_string s))), "ocamllex"; (fun s -> Sexp.List (Sexp.scan_sexps_conv ~f:(fun x -> x) (Lexing.from_string s))), "ocamllex_opt"; (fun s -> Sexp.List ( put_string_in_channel s (fun ch -> List.map Sexp.Annotated.get_sexp (Sexp.Annotated.input_sexps ch) ) )), "annot"; (fun s -> let sexps_with_layout = Sexp.With_layout.Parser.sexps Sexp.With_layout.Lexer.main (Lexing.from_string s) in let sexps = Sexp.With_layout.Forget.t_or_comments sexps_with_layout in Sexp.List sexps ), "layout-sexps"; ] let tests = ref 0 let failures = ref 0 let string_of_loc loc = Printf.sprintf "%s:%d:%d" loc.Lexing.pos_fname loc.Lexing.pos_lnum (loc.Lexing.pos_cnum - loc.Lexing.pos_bol) let same_parse_tree ?no_following_sibling ?(use_list_parsers=false) loc string1 string2 = let context_wrappers = wrap_in_context ?no_following_sibling () in List.iter (fun context_wrapper -> let string1 = context_wrapper string1 in let string2 = context_wrapper string2 in List.iter (fun (parser_, parser_name) -> List.iter (fun (adapt_newline, newline_style) -> incr tests; try let string1 = adapt_newline string1 in let string2 = adapt_newline string2 in let tree1 = parser_ string1 in let tree2 = parser_ string2 in if tree1 <> tree2 then ( incr failures; Printf.printf "test failure at %s (%s, %s)\n string1: %S tree1: %s\n string2: %S tree2: %s\n%!" (string_of_loc loc) parser_name newline_style string1 (Sexp.to_string tree1) string2 (Sexp.to_string tree2) ) with e -> incr failures; Printf.printf "test failure at %s (%s, %s, %s) on %S vs %S\n%!" (string_of_loc loc) (Printexc.to_string e) parser_name newline_style string1 string2 ) newline_adapters ) (if use_list_parsers then list_parsers else parsers) ) context_wrappers let same_parse_trees ?no_following_sibling loc string1 string2 = same_parse_tree ?no_following_sibling ~use_list_parsers:true loc string1 string2 let parse_fail ?no_following_sibling ?(use_list_parsers=false) loc string f = let context_wrappers = wrap_in_context ?no_following_sibling () in List.iter (fun context_wrapper -> let string = context_wrapper string in List.iter (fun (parser_, parser_name) -> List.iter (fun (adapt_newline, newline_style) -> incr tests; try let string = adapt_newline string in let tree = parser_ string in incr failures; Printf.printf "test failure at %s (%s, %s): should have thrown an exception\nstring: %S tree: %s\n%!" (string_of_loc loc) parser_name newline_style string (Sexp.to_string tree) with e -> if not (f e) then ( incr failures; Printf.printf "test failure at %s (%s, %s, %s)\n%!" (string_of_loc loc) (Printexc.to_string e) parser_name newline_style ) ) newline_adapters ) (if use_list_parsers then list_parsers else parsers) ) context_wrappers let parse_fail_trees ?no_following_sibling loc string f = parse_fail ?no_following_sibling ~use_list_parsers:true loc string f let grep pattern string = (* hopefully there is no need for escaping *) Sys.command ("echo '" ^ string ^ "' | grep -q '" ^ pattern ^ "'") = 0 let round_trip_all_characters () = let check_string s = let s' = let open Sexplib.Conv in s |> sexp_of_string |> Sexp.to_string |> Sexp.of_string |> string_of_sexp in assert (s = s') in for i = 0 to 255 do check_string (String.make 1 (Char.chr i)) done ;; let () = round_trip_all_characters (); same_parse_tree [%here] "(a)" "(a;\n)"; (* single line comment in a list *) same_parse_tree [%here] ";\nb" "b"; (* single line comment at toplevel *) same_parse_tree [%here] ";;\nb" "b"; (* single line comment don't nest *) same_parse_tree [%here] ";\"\nb" "b"; (* single line comment ignore quotes *) same_parse_tree [%here] "(a#)" "(a#;\n)"; parse_fail [%here] "a#|" (function | Failure s -> grep "comment tokens in unquoted atom" s | Sexp.Parse_error {Sexp.location = "maybe_parse_bad_atom_hash"; err_msg=_; parse_state=_ } -> true | _ -> false); parse_fail [%here] "a|#" (function | Failure s -> grep "comment tokens in unquoted atom" s | Sexp.Parse_error {Sexp.location = "maybe_parse_bad_atom_pipe"; err_msg=_; parse_state=_ } -> true | _ -> false); parse_fail [%here] "##|" (function | Failure s -> grep "comment tokens in unquoted atom" s | Sexp.Parse_error {Sexp.location = "maybe_parse_bad_atom_hash"; err_msg=_; parse_state=_ } -> true | _ -> false); parse_fail [%here] "||#" (function | Failure s -> grep "comment tokens in unquoted atom" s | Sexp.Parse_error {Sexp.location = "maybe_parse_bad_atom_pipe"; err_msg=_; parse_state=_ } -> true | _ -> false); parse_fail [%here] "#|" (* not terminated *) (function | Failure s -> grep "incomplete" s || grep "unterminated" s | _ -> false); parse_fail [%here] "|#" (* not started *) (function | Failure s -> grep "illegal end of comment" s | Sexp.Parse_error {Sexp.location = "maybe_parse_close_comment"; err_msg=_; parse_state=_ } -> true | _ -> false); parse_fail [%here] ~no_following_sibling:true "#;" (* not followed *) (function | Sexp.Parse_error _ | Failure _ -> true | _ -> false); same_parse_tree [%here] "#;a b" "b"; (* sexp comment + atom *) same_parse_tree [%here] "#;((a)) b" "b"; (* sexp comment + list *) same_parse_tree [%here] "#;\"#;\" b" "b"; (* sexp comment + quoted atom *) same_parse_tree [%here] "#;a;comment\nb" "b"; (* sexp comment + single line commment *) same_parse_tree [%here] "#;#|aa)|#comment b" "b"; (* sexp comment + block commment *) same_parse_tree [%here] "#;a #;(a) #;\"asd\" b" "b"; (* consecutive sexp comment + atom *) same_parse_tree [%here] "(#;a #;(a) #;b)" "()"; (* consecutive sexp comment + nothing *) same_parse_tree [%here] "#; #; #; comment1 comment2 comment3 a" "a"; (* nested sexp comment *) same_parse_tree [%here] "#| ; |# ()" "()"; (* single line comment are not parsed inside of blocks *) same_parse_tree [%here] "#|#||#|#a" "a"; (* consecutive comment opening are not parsed as one invalid atom *) (* why do we need a freaking space at the end?? *) same_parse_trees [%here] "a #; b c " "a c "; (* base case, accepting lists *) same_parse_trees [%here] "#;#;a b c d " "c d "; (* leading comments work alright *) same_parse_trees [%here] "#;#;a b " " "; (* leading comments work alright *) same_parse_trees [%here] "plop #;#;a b " "plop "; (* trailing comments work alright *) same_parse_trees [%here] "#;b " " "; (* leading comments in front of nothing *) (* making sure that '|' is still accepted in literals *) same_parse_tree [%here] "(a|b)" "(\"a|b\")"; same_parse_tree [%here] "(a | b)" "(a \"|\" b)"; same_parse_tree [%here] "((a)|b)" "((a)\"|b\")"; same_parse_tree [%here] "(b|(a))" "(\"b|\"(a))"; same_parse_trees [%here] "a|b " "\"a|b\" "; same_parse_trees [%here] "(a)|b " "(a)\"|b\" "; same_parse_trees [%here] "b|(a)" "\"b|\"(a)"; if !failures <> 0 then ( Printf.printf "%d / %d tests failed\n%!" !failures !tests; exit 2 ) else ( match Sys.argv with | [| _ |] -> Printf.printf "Done %d tests\n%!" !tests | _ -> () ) ppx_sexp_conv-113.33.03/test/printer_test.ml0000664002755601004200000001433712710355760020137 0ustar jdiminotechopen Sexplib module With_layout = Sexp.With_layout open Test_common (* a hack to ignore these tests for now *) let care_about_windows_newlines = false let string_of_sexp_with_layout t = let b = Buffer.create 10 in With_layout.Render.run (Buffer.add_char b) (With_layout.Render.sexp t); Buffer.contents b let string_of_sexps_with_layout t_list = let open With_layout.Render in let b = Buffer.create 10 in let m = return () in let m = List.fold_left (fun m t -> bind m (fun () -> sexp t) ) m t_list in With_layout.Render.run (fun c -> Buffer.add_char b c) m; Buffer.contents b module Interactive_stuff = struct let display_from_lexbuf make_lexbuf = let lexbuf = make_lexbuf () in let sexps_abs = With_layout.Parser.sexps_abs With_layout.Lexer.main lexbuf in let s = String.concat "\n" ( List.map (fun t -> Sexp.to_string_hum (Type_with_layout.Parsed.sexp_of_t_or_comment t) ) sexps_abs ) in Printf.printf "With_layout.Parsed.t:\n%s\n\n%!" s; let lexbuf = make_lexbuf () in let sexps = With_layout.Parser.sexps With_layout.Lexer.main lexbuf in let s = String.concat "\n" ( List.map (fun t -> Sexp.to_string_hum (With_layout.sexp_of_t_or_comment t)) sexps ) in Printf.printf "With_layout.t:\n%s\n\n%!" s; let s = string_of_sexps_with_layout sexps in Printf.printf "rendered:<<\n%s\n>>\n%!" s let is_a_file s = try let ch = open_in s in close_in ch; true with Sys_error _ -> false end let failures = ref 0 let total = ref 0 let split_newlines s = let acc = ref [] in let b = Buffer.create 10 in let split () = acc := Buffer.contents b :: !acc; Buffer.clear b in for i = 0 to String.length s - 1 do if s.[i] = '\n' then split (); Buffer.add_char b s.[i] done; split (); List.rev !acc let rstrip s = let rec aux i = if i = 0 then "" else match s.[i - 1] with | ' ' | '\t' | '\n' | '\r' -> aux (i - 1) | _ -> String.sub s 0 i in aux (String.length s) let normalize_string s = (* removing the spacing at the end and removing the trailing whitespace on each line except the final carriage return if any so that \r\n in the input stays \r\n in the output *) let s = rstrip s in let l = split_newlines s in let l = List.map (fun s -> let ends_with_cr = s <> "" && s.[String.length s - 1] = '\r' in let s = rstrip s in if ends_with_cr && care_about_windows_newlines then s ^ "\r" else s ) l in String.concat "" l let test_printer () = let tests = [ (* basic things *) "a"; "a b"; "a b "; "\na \n b \n "; "(\na \n) () b \n "; (* single line comments *) ";\n"; ";() b \n "; "(;\n)"; "(a;\nb)"; (* block comments *) "#||#"; "#| ((a((|#"; (* block comments + random contents *) "a\"#|\"b"; (* quoted atom with block comment start *) "a \"|#\" b"; (* quoted atom with block comment end *) "a #|\"|#\" b|#"; (* block comment with quoted atom *) "a \n#|\"\n|#\" b|#\n"; (* block comment with quoted atom and newlines *) (* sexp comment *) "#;out in"; (* standard case *) "#;out#;out-as-well ;still out\n finally-in"; (* consecutive sexp comments *) "#;#;out out-as-well ;still out\n finally-in"; (* nested sexp comments *) "#;#;(\"out\" )out-as-well ;still out\n finally-in"; (* nested sexp comments that comment out more complicated expressions *) "#;;line comment1\n;line comment2\nout in"; ] in List.iter (fun test_str -> List.iter (fun wrapper -> List.iter (fun (newline_adapter, newline_style) -> incr total; let test_str = newline_adapter (wrapper test_str) in let lexbuf = Lexing.from_string test_str in let sexps_opt = try Some (With_layout.Parser.sexps With_layout.Lexer.main lexbuf) with e -> incr failures; let str = Printexc.to_string e in Printf.printf "Failed to parse %S (%s):\n %s\n%!" test_str newline_style str; None in match sexps_opt with | None -> () | Some sexps -> let printed_str_opt = try Some (string_of_sexps_with_layout sexps) with e -> incr failures; let str = Printexc.to_string e in Printf.printf "Failed to print %S (%s):\n %s\n %s\n%!" test_str newline_style (Sexp.to_string (Sexp.List (With_layout.Forget.t_or_comments sexps))) str; None in match printed_str_opt with | None -> () | Some printed_str -> (* trailing whitespace (at the end of lines or at the end of file) is not handled by the parser/printer, except when they are in a comment but that is annoying to check so stripping everything from both strings *) if normalize_string test_str <> normalize_string printed_str then ( incr failures; Printf.printf "Comparison failed %S (%s):\n\ \ got %S after parsing + printing\n\ \ test after normalization: %S\n\ \ printed after normalization: %S\n%!" test_str newline_style printed_str (normalize_string test_str) (normalize_string printed_str); ) ) newline_adapters ) (wrap_in_context ()) ) tests let () = match Array.to_list Sys.argv with | [] -> () | [_] -> (* no commmand line argument -> non interactive part *) test_printer (); if !failures <> 0 then ( Printf.printf "%d / %d tests failed\n%!" !failures !total; exit 2 ) | _ :: l -> (* command line argument -> take the arguments as files or sexps to be parsed *) List.iter (fun s -> let make_lexbuf = if Interactive_stuff.is_a_file s then (fun () -> let cin = open_in s in let lexbuf = Lexing.from_channel cin in Gc.finalise (fun cin -> close_in cin) cin; lexbuf ) else (fun () -> Lexing.from_string s) in Interactive_stuff.display_from_lexbuf make_lexbuf ) l ppx_sexp_conv-113.33.03/test/path_test.mli0000664002755601004200000000000012710355760017537 0ustar jdiminotechppx_sexp_conv-113.33.03/test/io_test.mli0000664002755601004200000000000012710355760017212 0ustar jdiminotechppx_sexp_conv-113.33.03/test/test_common.ml0000664002755601004200000000211212710355760017730 0ustar jdiminotechopen Sexplib let () = Printexc.register_printer (function | Sexp.Parse_error {Sexp.location; err_msg; parse_state=_ } -> Some ( Printf.sprintf "Sexp.parse_error {location = %S; err_msg = %S}" location err_msg ) | _ -> None ) let wrap_in_context ?(no_following_sibling=false) () = [ (fun a -> a); (fun a -> "(" ^ a ^ ")"); (* checking if the spacing around braces changes something *) (fun a -> "( " ^ a ^ ")"); (fun a -> "(" ^ a ^ " )"); (fun a -> "( " ^ a ^ " )"); (fun a -> "( ( ( " ^ a ^ " ) ) )"); ] @ ( if no_following_sibling then [] else [ (fun a -> "( something " ^ a ^ "\"something else\")"); (fun a -> "( \"something else\"" ^ a ^ " something )"); (fun a -> "((\"something else\")" ^ a ^ "(something))"); ] ) let explode s = let acc = ref [] in for i = String.length s - 1 downto 0 do acc := s.[i] :: !acc done; !acc let newline_adapters = [ (fun s -> s), "unix"; (fun s -> String.concat "" (List.map (function '\n' -> "\r\n" | c -> String.make 1 c) (explode s))), "windows"; ] ppx_sexp_conv-113.33.03/test/ppx_sexp_test.ml0000664002755601004200000003417312710355760020322 0ustar jdiminotechopen Sexplib open Sexp open Conv module Sum_and_polymorphic_variants = struct type poly = [ `No_arg | `One_arg of int | `One_tuple of (int * string) | `Two_args of int * string ] [@@deriving sexp] let () = List.iter (fun (value, sexp) -> assert (sexp_of_poly value = sexp); assert (poly_of_sexp sexp = value); ) [ `No_arg, Sexp.Atom "No_arg"; `One_arg 1, Sexp.(List [Atom "One_arg"; Atom "1"]); `One_tuple (1, "a"), Sexp.(List [Atom "One_tuple"; List [Atom "1"; Atom "a"]]); `Two_args (1, "a"), Sexp.(List [Atom "Two_args"; List [Atom "1"; Atom "a"]]); ] type nominal = | No_arg | One_arg of int | One_tuple of (int * string) | Two_args of int * string [@@deriving sexp] let () = List.iter (fun (value, sexp) -> assert (sexp_of_nominal value = sexp); assert (nominal_of_sexp sexp = value); ) [ No_arg, Sexp.Atom "No_arg"; One_arg 1, Sexp.(List [Atom "One_arg"; Atom "1"]); One_tuple (1, "a"), Sexp.(List [Atom "One_tuple"; List [Atom "1"; Atom "a"]]); Two_args (1, "a"), Sexp.(List [Atom "Two_args"; Atom "1"; Atom "a"]); ] end module Records = struct type t = { a : int ; b : (float * string) list option } [@@deriving sexp] let t = { a = 2; b = Some [(1., "a"); (2.3, "b")] } let sexp = Sexp.of_string "((a 2)(b (((1 a)(2.3 b)))))" let () = assert (t_of_sexp sexp = t) let () = assert (sexp_of_t t = sexp) end module User_specified_conversion = struct type my_float = float let sexp_of_my_float n = Atom (Printf.sprintf "%.4f" n) let my_float_of_sexp = float_of_sexp let my_float : my_float = 1.2 let sexp = Sexp.Atom "1.2000" let () = assert (my_float_of_sexp sexp = my_float) let () = assert (sexp_of_my_float my_float = sexp) end module Exceptions : sig exception E0 [@@deriving sexp] exception E1 of string [@@deriving sexp] exception E2 of string * int [@@deriving sexp] exception E_tuple of (string * int) [@@deriving sexp] end = struct exception E0 [@@deriving sexp] exception E1 of string [@@deriving sexp] exception E2 of string * int [@@deriving sexp] exception E_tuple of (string * int) [@@deriving sexp] let cases = [ E0, "ppx_sexp_test.ml.Exceptions.E0" ; E1 "a", "(ppx_sexp_test.ml.Exceptions.E1 a)" ; E2 ("b", 2), "(ppx_sexp_test.ml.Exceptions.E2 b 2)" ; E_tuple ("c", 3), "(ppx_sexp_test.ml.Exceptions.E_tuple(c 3))" ] let () = List.iter (fun (exn, sexp_as_str) -> let sexp = Sexp.of_string sexp_as_str in assert ([%sexp_of: exn] exn = sexp); ) cases end module Abtract_types_are_allowed_in_structures : sig type t [@@deriving sexp] end = struct type t [@@deriving sexp] end module Manifest_types = struct type a = { t : int } type b = a = { t : int } [@@deriving sexp] end module Uses_of_exn = struct type t = int * exn [@@deriving sexp_of] end module Function_types : sig type t1 = int -> unit [@@deriving sexp] type t2 = label:int -> ?optional:int -> unit -> unit [@@deriving sexp] end = struct type t1 = int -> unit [@@deriving sexp] type t2 = label:int -> ?optional:int -> unit -> unit [@@deriving sexp] end module No_unused_rec = struct type r = { r : int } [@@deriving sexp] end module Field_name_should_not_be_rewritten = struct open No_unused_rec type nonrec r = { r : r } let _ = fun (r : r) -> r.r end module Polymorphic_variant_inclusion = struct type sub1 = [ `C1 | `C2 ] [@@deriving sexp] type 'b sub2 = [ `C4 | `C5 of 'b ] [@@deriving sexp] type ('a, 'b) t = [ sub1 | `C3 of [ `Nested of 'a ] | 'b sub2 | `C6 ] option [@@deriving sexp] let cases : ((string * string, float) t * _) list = [ None, "()" ; Some `C1, "(C1)" ; Some `C2, "(C2)" ; Some (`C3 (`Nested ("a", "b"))), "((C3 (Nested (a b))))" ; Some `C4, "(C4)" ; Some (`C5 1.5), "((C5 1.5))" ; Some `C6, "(C6)" ] let () = List.iter (fun (t, sexp_as_str) -> let sexp = Sexp.of_string sexp_as_str in assert ([%of_sexp: (string * string, float) t] sexp = t); assert ([%sexp_of: (string * string, float) t] t = sexp); ) cases type sub1_alias = sub1 [@@deriving sexp_poly] type u = [ `A | sub1_alias | `D ] [@@deriving sexp] let cases : (u * _) list = [ `A, "A" ; `C1, "C1" ; `C2, "C2" ; `D, "D" ] let () = List.iter (fun (u, sexp_as_str) -> let sexp = Sexp.of_string sexp_as_str in assert ([%of_sexp: u] sexp = u); assert ([%sexp_of: u] u = sexp); ) cases end module Polymorphic_record_field = struct type 'x t = { poly : 'a 'b. 'a list ; maybe_x : 'x option } [@@deriving sexp] let t x = { poly = []; maybe_x = Some x } let sexp = Sexp.of_string "((poly ())(maybe_x (1)))" let () = assert (t_of_sexp int_of_sexp sexp = t 1) let () = assert (sexp_of_t sexp_of_int (t 1) = sexp) end module No_unused_value_warnings : sig end = struct module No_warning : sig type t = [ `A ] [@@deriving sexp] end = struct type t = [ `A ] [@@deriving sexp] end module Empty = struct end module No_warning2(X : sig type t [@@deriving sexp] end) = struct end (* this one can't be handled (what if Empty was a functor, huh?) *) (* module No_warning3(X : sig type t with sexp end) = Empty *) module type S = sig type t = [ `A ] [@@deriving sexp] end module No_warning4 : S = struct type t = [ `A ] [@@deriving sexp] end module No_warning5 : S = ((struct type t = [ `A ] [@@deriving sexp] end : S) : S) module Nested_functors (M1 : sig type t [@@deriving sexp] end) (M2 : sig type t [@@deriving sexp] end) = struct end let () = let module M : sig type t [@@deriving sexp] end = struct type t [@@deriving sexp] end in () module Include = struct include (struct type t = int [@@deriving sexp] end : sig type t [@@deriving sexp] end with type t := int) end end module Default = struct type t = { a : int [@default 2]; } [@@deriving sexp] let () = assert (Sexp.(List [List [Atom "a"; Atom "1"]]) = sexp_of_t { a = 1 }) let () = assert (Sexp.(List [List [Atom "a"; Atom "2"]]) = sexp_of_t { a = 2 }) let () = assert (t_of_sexp (Sexp.(List [List [Atom "a"; Atom "1"]])) = { a = 1 }) let () = assert (t_of_sexp (Sexp.(List [List [Atom "a"; Atom "2"]])) = { a = 2 }) let () = assert (t_of_sexp (Sexp.(List [])) = { a = 2 }) end module Type_alias = struct (* checking that the [as 'a] is supported and ignored in signatures, that it still exports the sexp_of_t__ when needed *) module B : sig type a = [ `A ] type t = ([`A] as 'a) constraint 'a = a [@@deriving sexp] end = struct type a = [ `A ] [@@deriving sexp] type t = [ `A ] [@@deriving sexp] end let () = assert (Sexp.to_string (B.sexp_of_t `A) = "A"); assert (`A = B.t_of_sexp (Sexp.of_string "A")); () module B2 = struct type t = [ B.t | `B ] [@@deriving sexp] end module C : sig type t = (int as 'a) [@@deriving sexp] end = struct type t = int [@@deriving sexp] end module D : sig type t = 'a constraint 'a = int [@@deriving sexp] end = struct type t = int [@@deriving sexp] end end module Tricky_variants = struct (* Checking that the generated code compiles (there used to be a problem with subtyping constraints preventing proper generalization). *) type t = [ `a ] [@@deriving sexp] type 'a u = [ t | `b of 'a ] * int [@@deriving sexp] end module Drop_default = struct type t = { a : int [@default 2] [@sexp_drop_default]; } [@@deriving sexp] let () = assert (Sexp.(List [List [Atom "a"; Atom "1"]]) = sexp_of_t { a = 1 }) let () = assert (Sexp.(List []) = sexp_of_t { a = 2 }) let () = assert (t_of_sexp (Sexp.(List [List [Atom "a"; Atom "1"]])) = { a = 1 }) let () = assert (t_of_sexp (Sexp.(List [List [Atom "a"; Atom "2"]])) = { a = 2 }) let () = assert (t_of_sexp (Sexp.(List [])) = { a = 2 }) end module Drop_if = struct type t = { a : int [@default 2] [@sexp_drop_if fun x -> x mod 2 = 0] } [@@deriving sexp] let () = assert (Sexp.(List [List [Atom "a"; Atom "1"]]) = sexp_of_t { a = 1 }) let () = assert (Sexp.(List []) = sexp_of_t { a = 2 }) let () = assert (Sexp.(List [List [Atom "a"; Atom "3"]]) = sexp_of_t { a = 3 }) let () = assert (Sexp.(List []) = sexp_of_t { a = 4 }) let () = assert (t_of_sexp (Sexp.(List [List [Atom "a"; Atom "1"]])) = { a = 1 }) let () = assert (t_of_sexp (Sexp.(List [List [Atom "a"; Atom "2"]])) = { a = 2 }) let () = assert (t_of_sexp (Sexp.(List [List [Atom "a"; Atom "3"]])) = { a = 3 }) let () = assert (t_of_sexp (Sexp.(List [List [Atom "a"; Atom "4"]])) = { a = 4 }) let () = assert (t_of_sexp (Sexp.(List [])) = { a = 2 }) type u = { a : int [@sexp_drop_if fun x -> (* pa_type_conv used to drop parens altogether, causing type errors in the following code *) let pair = (x, 2) in match Some pair with | None -> true | Some (x, y) -> x = y ] } [@@deriving sexp] end module No_unused_rec_warning = struct type r = { field : r -> unit } [@@deriving sexp_of] end module True_and_false = struct type t = | True | False [@@deriving sexp] let () = assert (Sexp.to_string (sexp_of_t True) = "True") let () = assert (Sexp.to_string (sexp_of_t False) = "False") let () = assert (True = t_of_sexp (Sexp.of_string "True")) let () = assert (False = t_of_sexp (Sexp.of_string "False")) let () = assert (True = t_of_sexp (Sexp.of_string "true")) let () = assert (False = t_of_sexp (Sexp.of_string "false")) type u = | True of int | False of int [@@deriving sexp] let () = assert (Sexp.to_string (sexp_of_u (True 1)) = "(True 1)") let () = assert (Sexp.to_string (sexp_of_u (False 2)) = "(False 2)") let () = assert (True 1 = u_of_sexp (Sexp.of_string "(True 1)")) let () = assert (False 2 = u_of_sexp (Sexp.of_string "(False 2)")) let () = assert (True 1 = u_of_sexp (Sexp.of_string "(true 1)")) let () = assert (False 2 = u_of_sexp (Sexp.of_string "(false 2)")) exception True [@@deriving sexp] let () = assert ("ppx_sexp_test.ml.True_and_false.True" = Sexp.to_string (sexp_of_exn True)) exception False of int [@@deriving sexp] let () = assert ("(ppx_sexp_test.ml.True_and_false.False 1)" = Sexp.to_string (sexp_of_exn (False 1))) type v = [ `True | `False of int ] [@@deriving sexp] let () = assert (Sexp.to_string (sexp_of_v `True) = "True") let () = assert (Sexp.to_string (sexp_of_v (`False 2)) = "(False 2)") end module Gadt = struct let is_eq sexp str = let sexp2 = Sexp.of_string str in if sexp <> sexp2 then begin Printf.printf "%S vs %S\n%!" (Sexp.to_string sexp) str; assert false end (* plain type without argument *) type 'a s = Packed : 'a s [@@deriving sexp_of] let () = is_eq ([%sexp_of: int s] Packed) "Packed" (* two kind of existential variables *) type 'a t = Packed : 'a * _ * 'b sexp_opaque -> 'a t [@@deriving sexp_of] let () = is_eq ([%sexp_of: int t] (Packed (2, "asd", 1.))) "(Packed 2 _ )" (* plain type with argument *) type 'a u = A : 'a -> 'a u [@@deriving sexp_of] let () = is_eq ([%sexp_of: int u] (A 2)) "(A 2)" (* recursive *) type v = A : v option -> v [@@deriving sexp_of] let () = is_eq ([%sexp_of: v] (A (Some (A None)))) "(A((A())))" (* implicit existential variable *) type w = A : 'a * int * ('a -> string) -> w [@@deriving sexp_of] let () = is_eq ([%sexp_of: w] (A (1., 2, string_of_float))) "(A _ 2 )" (* tricky variable naming *) type 'a x = A : 'a -> 'b x [@@deriving sexp_of] let () = is_eq ([%sexp_of: int x] (A 1.)) "(A _)" (* unused but colliding variables *) type (_, _) y = A : ('a, 'a) y [@@deriving sexp_of] let () = is_eq ([%sexp_of: (int, int) y] A) "A" (* making sure we're not reversing parameters *) type (_, _) z = A : ('a * 'b) -> ('a, 'b) z [@@deriving sexp_of] let () = is_eq ([%sexp_of: (int, string) z] (A (1, "a"))) "(A (1 a))" end module Anonymous_variable = struct type _ t = int [@@deriving sexp] let () = assert (Sexp.to_string ([%sexp_of: _ t] 2) = "2") let () = assert ([%of_sexp: _ t] (Sexp.of_string "2") = 2) (* making sure we don't generate signatures like (_ -> Sexp.t) -> _ t -> Sexp.t which are too general *) module M : sig type _ t [@@deriving sexp] end = struct type 'a t = 'a [@@deriving sexp] end end module Record_field_disambiguation = struct type a = { fl: float; b : b } and b = { fl: int } [@@deriving sexp] end module Private = struct type t = private int [@@deriving sexp_of] type ('a, 'b) u = private t [@@deriving sexp_of] type ('a, 'b, 'c) v = private ('a, 'b) u [@@deriving sexp_of] end module Nonregular_types = struct type 'a nonregular = | Leaf of 'a | Branch of ('a * 'a) nonregular [@@deriving sexp] type 'a variant = [ `A of 'a ] [@@deriving sexp] type ('a, 'b) nonregular_with_variant = | Branch of ([ | 'a list variant ], 'b) nonregular_with_variant [@@deriving sexp] end module Magic_types = struct type t = { sexp_array : int sexp_array ; sexp_list : int sexp_list ; sexp_option : int sexp_option ; sexp_bool : sexp_bool } [@@deriving sexp] let sexp = Sexp.of_string "()" let t = { sexp_array = [||] ; sexp_list = [] ; sexp_option = None ; sexp_bool = false } let () = assert (t_of_sexp sexp = t) let () = assert (sexp_of_t t = sexp) let sexp = Sexp.of_string "((sexp_array (1 2))\ (sexp_list (3 4))\ (sexp_option 5)\ (sexp_bool))" let t = { sexp_array = [|1; 2|] ; sexp_list = [3; 4] ; sexp_option = Some 5 ; sexp_bool = true } let () = assert (t_of_sexp sexp = t) let () = assert (sexp_of_t t = sexp) type u = | A of int sexp_list [@@deriving sexp] type v = [ `A of int sexp_list ] [@@deriving sexp] let sexp = Sexp.of_string "(A 1 2 3)" let u = A [1; 2; 3] let v = `A [1; 2; 3] let () = assert (u_of_sexp sexp = u) let () = assert (sexp_of_u u = sexp) let () = assert (v_of_sexp sexp = v) let () = assert (sexp_of_v v = sexp) end module Variance = struct type (+'a, -'b, 'c, +_, -_, _) t [@@deriving sexp] end