matthieu
/
dune
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' into no-private-module-name

This commit is contained in:
Rudi Grinberg 2018-06-07 17:51:36 +07:00 committed by GitHub
parent 0c048ac0c5 aeca0f763d
commit 08c46dff28
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 316 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGES.md
View File

@ -62,6 +62,10 @@ next
- Make the output of Dune slightly more deterministic when run from
inside Dune (#855, @diml)
- Simplify quoting behavior of variables. All values are now multi-valued and
whether a multi valued variable is allowed is determined by the quoting and
substitution context it appears in. (#849, fix #701, @rgrinberg)
1.0+beta20 (10/04/2018)
-----------------------

166
src/action.ml
View File

@ -34,7 +34,7 @@ struct
; cstr "ignore-stderr" (t @> nil) (fun t -> Ignore (Stderr, t))
; cstr "ignore-outputs" (t @> nil) (fun t -> Ignore (Outputs, t))
; cstr "progn" (rest t) (fun l -> Progn l)
; cstr "echo" (string @> nil) (fun x -> Echo x)
; cstr "echo" (string @> rest string) (fun x xs -> Echo (x::xs))
; cstr "cat" (path @> nil) (fun x -> Cat x)
; cstr "copy" (path @> path @> nil) (fun src dst -> Copy (src, dst))
(*
@ -78,7 +78,8 @@ struct
]
| Progn l -> List (Sexp.unsafe_atom_of_string "progn"
:: List.map l ~f:sexp_of_t)
| Echo x -> List [Sexp.unsafe_atom_of_string "echo"; string x]
| Echo xs ->
List (Sexp.unsafe_atom_of_string "echo" :: List.map xs ~f:string)
| Cat x -> List [Sexp.unsafe_atom_of_string "cat"; path x]
| Copy (x, y) ->
List [Sexp.unsafe_atom_of_string "copy"; path x; path y]
@ -150,7 +151,7 @@ module Make_mapper
| Ignore (outputs, t) ->
Ignore (outputs, map t ~dir ~f_program ~f_string ~f_path)
| Progn l -> Progn (List.map l ~f:(fun t -> map t ~dir ~f_program ~f_string ~f_path))
| Echo x -> Echo (f_string ~dir x)
| Echo xs -> Echo (List.map xs ~f:(f_string ~dir))
| Cat x -> Cat (f_path ~dir x)
| Copy (x, y) -> Copy (f_path ~dir x, f_path ~dir y)
| Symlink (x, y) ->
@ -270,69 +271,13 @@ module Unresolved = struct
| Search s -> Ok (f s))
end
module Var_expansion = struct
module Concat_or_split = struct
type t =
| Concat (* default *)
| Split (* the variable is a "split" list of items *)
end
let prog_and_args_of_values p ~dir =
match p with
| [] -> (Unresolved.Program.Search "", [])
| Value.Path p :: xs -> (This p, Value.L.to_strings ~dir xs)
| String s :: xs ->
(Unresolved.Program.of_string ~dir s, Value.L.to_strings ~dir xs)
open Concat_or_split
type t =
| Paths of Path.t list * Concat_or_split.t
| Strings of string list * Concat_or_split.t
let is_multivalued = function
| Paths (_, Split) | Strings (_, Split) -> true
| Paths (_, Concat) | Strings (_, Concat) -> false
type context = Path.t (* For String_with_vars.Expand_to *)
let concat = function
| [s] -> s
| l -> String.concat ~sep:" " l
let string_of_path ~dir p = Path.reach ~from:dir p
let path_of_string dir s = Path.relative dir s
let to_strings dir = function
| Strings (l, Split ) -> l
| Strings (l, Concat) -> [concat l]
| Paths (l, Split ) -> List.map l ~f:(string_of_path ~dir)
| Paths (l, Concat) -> [concat (List.map l ~f:(string_of_path ~dir))]
let to_string (dir: context) = function
| Strings (l, _) -> concat l
| Paths (l, _) -> concat (List.map l ~f:(string_of_path ~dir))
let to_path dir = function
| Strings (l, _) -> path_of_string dir (concat l)
| Paths ([p], _) -> p
| Paths (l, _) ->
path_of_string dir (concat (List.map l ~f:(string_of_path ~dir)))
let to_prog_and_args dir exp : Unresolved.Program.t * string list =
let module P = Unresolved.Program in
match exp with
| Paths ([p], _) -> (This p, [])
| Strings ([s], _) -> (P.of_string ~dir s, [])
| Paths ([], _) | Strings ([], _) -> (Search "", [])
| Paths (l, Concat) ->
(This
(path_of_string dir
(concat (List.map l ~f:(string_of_path ~dir)))),
[])
| Strings (l, Concat) ->
(P.of_string ~dir (concat l), l)
| Paths (p :: l, Split) ->
(This p, List.map l ~f:(string_of_path ~dir))
| Strings (s :: l, Split) ->
(P.of_string ~dir s, l)
end
module VE = Var_expansion
module To_VE = String_with_vars.Expand_to(VE)
module SW = String_with_vars
module Unexpanded = struct
@ -370,37 +315,33 @@ module Unexpanded = struct
include Past
module E = struct
let expand ~generic ~special ~map ~dir ~f = function
| Left x -> map x
| Right template ->
match To_VE.expand dir template ~f with
| Expansion e -> special dir e
| String s -> generic dir s
[@@inlined always]
let expand ~dir ~mode ~f ~l ~r =
Either.map ~l
~r:(fun s -> r (String_with_vars.expand s ~dir ~f ~mode) ~dir)
let string ~dir ~f x =
expand ~dir ~f x
~generic:(fun _dir x -> x)
~special:VE.to_string
~map:(fun x -> x)
let string =
expand ~mode:Single
~l:(fun x -> x)
~r:Value.to_string
let strings ~dir ~f x =
expand ~dir ~f x
~generic:(fun _dir x -> [x])
~special:VE.to_strings
~map:(fun x -> [x])
let strings =
expand ~mode:Many
~l:(fun x -> [x])
~r:Value.L.to_strings
let path ~dir ~f x =
expand ~dir ~f x
~generic:VE.path_of_string
~special:VE.to_path
~map:(fun x -> x)
let path e =
let error_loc =
match e with
| Left _ -> None
| Right r -> Some (String_with_vars.loc r) in
expand ~mode:Single
~l:(fun x -> x)
~r:Value.(to_path ?error_loc) e
let prog_and_args ~dir ~f x =
expand ~dir ~f x
~generic:(fun _dir s -> (Program.of_string ~dir s, []))
~special:VE.to_prog_and_args
~map:(fun x -> (x, []))
let prog_and_args =
expand ~mode:Many
~l:(fun x -> (x, []))
~r:prog_and_args_of_values
end
let rec expand t ~dir ~map_exe ~f : Unresolved.t =
@ -425,7 +366,7 @@ module Unexpanded = struct
| Ignore (outputs, t) ->
Ignore (outputs, expand t ~dir ~map_exe ~f)
| Progn l -> Progn (List.map l ~f:(fun t -> expand t ~dir ~map_exe ~f))
| Echo x -> Echo (E.string ~dir ~f x)
| Echo xs -> Echo (List.concat_map xs ~f:(E.strings ~dir ~f))
| Cat x -> Cat (E.path ~dir ~f x)
| Copy (x, y) ->
Copy (E.path ~dir ~f x, E.path ~dir ~f y)
@ -463,31 +404,18 @@ module Unexpanded = struct
end
module E = struct
let expand ~generic ~special ~dir ~f template =
match To_VE.partial_expand dir template ~f with
| Expansion e -> Left (special dir e)
| String s -> Left (generic dir s)
let expand ~dir ~mode ~f ~map x =
match String_with_vars.partial_expand ~mode ~dir ~f x with
| Expanded e -> Left (map e ~dir)
| Unexpanded x -> Right x
let string ~dir ~f x =
expand ~dir ~f x
~generic:(fun _dir x -> x)
~special:VE.to_string
let strings ~dir ~f x =
expand ~dir ~f x
~generic:(fun _dir x -> [x])
~special:VE.to_strings
let path ~dir ~f x =
expand ~dir ~f x
~generic:VE.path_of_string
~special:VE.to_path
let prog_and_args ~dir ~f x =
expand ~dir ~f x
~generic:(fun dir s -> (Unresolved.Program.of_string ~dir s, []))
~special:VE.to_prog_and_args
let string = expand ~mode:Single ~map:Value.to_string
let strings = expand ~mode:Many ~map:Value.L.to_strings
let cat_strings = expand ~mode:Many ~map:Value.L.concat
let path x =
let error_loc = String_with_vars.loc x in
expand ~mode:Single ~map:(Value.to_path ~error_loc) x
let prog_and_args = expand ~mode:Many ~map:prog_and_args_of_values
end
let rec partial_expand t ~dir ~map_exe ~f : Partial.t =
@ -531,7 +459,7 @@ module Unexpanded = struct
| Ignore (outputs, t) ->
Ignore (outputs, partial_expand t ~dir ~map_exe ~f)
| Progn l -> Progn (List.map l ~f:(fun t -> partial_expand t ~dir ~map_exe ~f))
| Echo x -> Echo (E.string ~dir ~f x)
| Echo xs -> Echo (List.map xs ~f:(E.cat_strings ~dir ~f))
| Cat x -> Cat (E.path ~dir ~f x)
| Copy (x, y) ->
Copy (E.path ~dir ~f x, E.path ~dir ~f y)
@ -760,7 +688,7 @@ let rec exec t ~ectx ~dir ~env ~stdout_to ~stderr_to =
exec t ~ectx ~dir ~stdout_to ~stderr_to
~env:(Env.add env ~var ~value)
| Redirect (Stdout, fn, Echo s) ->
Io.write_file fn s;
Io.write_file fn (String.concat s ~sep:" ");
Fiber.return ()
| Redirect (outputs, fn, Run (Ok prog, args)) ->
let out = Process.File fn in
@ -777,7 +705,7 @@ let rec exec t ~ectx ~dir ~env ~stdout_to ~stderr_to =
redirect ~ectx ~dir outputs Config.dev_null t ~env ~stdout_to ~stderr_to
| Progn l ->
exec_list l ~ectx ~dir ~env ~stdout_to ~stderr_to
| Echo str -> exec_echo stdout_to str
| Echo strs -> exec_echo stdout_to (String.concat strs ~sep:" ")
| Cat fn ->
Io.with_file_in fn ~f:(fun ic ->
let oc =

21
src/action.mli
View File

@ -1,22 +1,5 @@
open! Import
module Var_expansion : sig
module Concat_or_split : sig
type t =
| Concat (** default *)
| Split (** the variable is a "split" list of items *)
end
type t =
| Paths of Path.t list * Concat_or_split.t
| Strings of string list * Concat_or_split.t
val to_string : Path.t -> t -> string
(** [to_string dir v] convert the variable expansion to a string.
If it is a path, the corresponding string will be relative to
[dir]. *)
end
module Outputs : module type of struct include Action_intf.Outputs end
(** result of the lookup of a program, the path to it or information about the
@ -99,7 +82,7 @@ module Unexpanded : sig
: t
-> dir:Path.t
-> map_exe:(Path.t -> Path.t)
-> f:(Loc.t -> String.t -> Var_expansion.t option)
-> f:(Loc.t -> String.t -> Value.t list option)
-> Unresolved.t
end
@ -107,7 +90,7 @@ module Unexpanded : sig
: t
-> dir:Path.t
-> map_exe:(Path.t -> Path.t)
-> f:(Loc.t -> string -> Var_expansion.t option)
-> f:(Loc.t -> string -> Value.t list option)
-> Partial.t
end

4
src/action_intf.ml
View File

@ -29,7 +29,7 @@ module type Ast = sig
| Redirect of Outputs.t * path * t
| Ignore of Outputs.t * t
| Progn of t list
| Echo of string
| Echo of string list
| Cat of path
| Copy of path * path
| Symlink of path * path
@ -61,7 +61,7 @@ module type Helpers = sig
val ignore_stderr : t -> t
val ignore_outputs : t -> t
val progn : t list -> t
val echo : string -> t
val echo : string list -> t
val cat : path -> t
val copy : path -> path -> t
val symlink : path -> path -> t

3
src/gen_rules.ml
View File

@ -176,8 +176,7 @@ module Gen(P : Install_rules.Params) = struct
+-----------------------------------------------------------------+ *)
let interpret_locks ~dir ~scope locks =
List.map locks ~f:(fun s ->
Path.relative dir (SC.expand_vars sctx ~dir ~scope s))
List.map locks ~f:(SC.expand_vars_path sctx ~dir ~scope)
let user_rule (rule : Rule.t) ~dir ~scope =
let targets : SC.Action.targets =

8
src/inline_tests.ml
View File

@ -187,8 +187,7 @@ include Sub_system.Register_end_point(
in
let extra_vars =
String.Map.singleton "library-name"
(Action.Var_expansion.Strings ([lib.name], Concat))
String.Map.singleton "library-name" ([Value.String lib.name])
in
let runner_libs =
@ -210,10 +209,9 @@ include Sub_system.Register_end_point(
let target = Path.relative inline_test_dir main_module_filename in
let source_modules = Module.Name.Map.values source_modules in
let files ml_kind =
Action.Var_expansion.Paths (
Value.L.paths (
List.filter_map source_modules ~f:(fun m ->
Module.file m ~dir ml_kind),
Split)
Module.file m ~dir ml_kind))
in
let extra_vars =
List.fold_left

6
src/preprocessing.ml
View File

@ -475,8 +475,7 @@ let lint_module sctx ~dir ~dep_kind ~lint ~lib_name ~scope ~dir_kind =
>>| fun (exe, driver) ->
(exe,
let extra_vars =
String_map.singleton "corrected-suffix"
(Action.Var_expansion.Strings ([corrected_suffix], Split))
String_map.singleton "corrected-suffix" [Value.String corrected_suffix]
in
Build.memoize "ppx flags"
(SC.expand_and_eval_set sctx driver.info.lint_flags
@ -558,8 +557,7 @@ let make sctx ~dir ~dep_kind ~lint ~preprocess
get_ppx_driver sctx ~loc ~scope ~dir_kind pps >>| fun (exe, driver) ->
(exe,
let extra_vars =
String_map.singleton "corrected-suffix"
(Action.Var_expansion.Strings ([corrected_suffix], Split))
String_map.singleton "corrected-suffix" [Value.String corrected_suffix]
in
Build.memoize "ppx flags"
(SC.expand_and_eval_set sctx driver.info.flags

5
src/stdune/either.ml
View File

@ -1,3 +1,8 @@
type ('a, 'b) t =
| Left of 'a
| Right of 'b
let map t ~l ~r =
match t with
| Left x -> l x
| Right x -> r x

2
src/stdune/either.mli
View File

@ -3,3 +3,5 @@
type ('a, 'b) t =
| Left of 'a
| Right of 'b
val map : ('a, 'b) t -> l:('a -> 'c) -> r:('b -> 'c) -> 'c

5
src/stdune/string.ml
View File

@ -214,3 +214,8 @@ let enumerate_gen s =
let enumerate_and = enumerate_gen "and"
let enumerate_or = enumerate_gen "or"
let concat ~sep = function
| [] -> ""
| [x] -> x
| xs -> concat ~sep xs

161
src/string_with_vars.ml
View File

@ -104,105 +104,92 @@ let string_of_var syntax v =
| Parens -> sprintf "$(%s)" v
| Braces -> sprintf "${%s}" v
module type EXPANSION = sig
type t
val is_multivalued : t -> bool
type context
val to_string : context -> t -> string
end
let concat_rev = function
| [] -> ""
| [s] -> s
| l -> String.concat (List.rev l) ~sep:""
module Expand = struct
module Full = struct
type nonrec 'a t =
| Expansion of 'a
| String of string
end
module Partial = struct
type nonrec 'a t =
| Expansion of 'a
| String of string
| Unexpanded of t
end
module Mode = struct
type 'a t =
| Single : Value.t t
| Many : Value.t list t
let string
: type a. a t -> string -> a
= fun t s ->
match t with
| Single -> Value.String s
| Many -> [Value.String s]
let value
: type a. a t -> Value.t list -> a option
= fun t s ->
match t, s with
| Many, s -> Some s
| Single, [s] -> Some s
| Single, _ -> None
end
module Expand_to(V: EXPANSION) = struct
let expand ctx t ~f =
match t.items with
| [Var (syntax, v)] when not t.quoted ->
(* Unquoted single var *)
(match f t.loc v with
| Some e -> Expand.Full.Expansion e
| None -> Expand.Full.String (string_of_var syntax v))
| _ ->
Expand.Full.String (List.map t.items ~f:(function
| Text s -> s
| Var (syntax, v) ->
match f t.loc v with
| Some x ->
if not t.quoted && V.is_multivalued x then
Loc.fail t.loc "please quote the string \
containing the list variable %s"
(string_of_var syntax v)
else V.to_string ctx x
| None -> string_of_var syntax v)
|> String.concat ~sep:"")
let partial_expand ctx t ~f =
let commit_text acc_text acc =
let s = concat_rev acc_text in
if s = "" then acc else Text s :: acc
in
let rec loop acc_text acc items =
match items with
| [] -> begin
match acc with
| [] -> Expand.Partial.String (concat_rev acc_text)
| _ -> Unexpanded { t with items = List.rev (commit_text acc_text acc) }
end
| Text s :: items -> loop (s :: acc_text) acc items
| Var (syntax, v) as it :: items ->
match f t.loc v with
| None -> loop [] (it :: commit_text acc_text acc) items
| Some x ->
if not t.quoted && V.is_multivalued x then
Loc.fail t.loc "please quote the string containing the \
list variable %s" (string_of_var syntax v)
else loop (V.to_string ctx x :: acc_text) acc items
in
match t.items with
| [Var (_, v)] when not t.quoted ->
(* Unquoted single var *)
(match f t.loc v with
| Some e -> Expand.Partial.Expansion e
| None -> Expand.Partial.Unexpanded t)
| _ -> loop [] [] t.items
module Partial = struct
type nonrec 'a t =
| Expanded of 'a
| Unexpanded of t
end
module String_expansion = struct
type t = string
let is_multivalued _ = false
type context = unit
let to_string () (s: string) = s
end
let invalid_multivalue syntax ~var t x =
Loc.fail t.loc "Variable %s expands to %d values, \
however a single value is expected here. \
Please quote this atom."
(string_of_var syntax var) (List.length x)
module S = Expand_to(String_expansion)
let partial_expand t ~mode ~dir ~f =
let commit_text acc_text acc =
let s = concat_rev acc_text in
if s = "" then acc else Text s :: acc
in
let rec loop acc_text acc items =
match items with
| [] ->
begin match acc with
| [] -> Partial.Expanded (Mode.string mode (concat_rev acc_text))
| _ -> Unexpanded { t with items = List.rev (commit_text acc_text acc) }
end
| Text s :: items -> loop (s :: acc_text) acc items
| Var (syntax, var) as it :: items ->
begin match f syntax t.loc var with
| Some ([] | _::_::_ as e) when not t.quoted ->
invalid_multivalue syntax ~var t e
| Some t ->
loop (Value.L.concat ~dir t :: acc_text) acc items
| None -> loop [] (it :: commit_text acc_text acc) items
end
in
match t.items with
| [] -> Partial.Expanded (Mode.string mode "")
| [Text s] -> Expanded (Mode.string mode s)
| [Var (syntax, v)] when not t.quoted ->
(* Unquoted single var *)
begin match f syntax t.loc v with
| Some e -> Partial.Expanded (
match Mode.value mode e with
| None -> invalid_multivalue syntax ~var:v t e
| Some s -> s)
| None -> Unexpanded t
end
| _ -> loop [] [] t.items
let expand t ~f =
match S.expand () t ~f with
| Expand.Full.String s
| Expansion s -> s
let expand t ~mode ~dir ~f =
match
partial_expand t ~mode ~dir ~f:(fun syntax loc var ->
match f loc var with
| None -> Some [Value.String (string_of_var syntax var)]
| s -> s)
with
| Partial.Expanded s -> s
| Unexpanded _ -> assert false (* we are expanding every variable *)
let partial_expand t ~f =
match S.partial_expand () t ~f with
| Expand.Partial.Expansion s -> Left s
| String s -> Left s
| Unexpanded s -> Right s
let partial_expand t ~mode ~dir ~f =
partial_expand t ~mode ~dir ~f:(fun _ loc v -> f loc v)
let to_string t =
match t.items with

79
src/string_with_vars.mli
View File

@ -45,67 +45,28 @@ val iter : t -> f:(Loc.t -> string -> unit) -> unit
val is_var : t -> name:string -> bool
module type EXPANSION = sig
type t
(** The value to which variables are expanded. *)
val is_multivalued : t -> bool
(** Report whether the value is a multivalued one (such as for
example ${@}) which much be in quoted strings to be concatenated
to text or other variables. *)
type context
(** Context needed to expand values of type [t] to strings. *)
val to_string : context -> t -> string
(** When needing to expand with text portions or if the
string-with-vars is quoted, the value is converted to a string
using [to_string]. *)
module Mode : sig
type 'a t =
| Single : Value.t t
| Many : Value.t list t
end
module Expand : sig
module Full : sig
type nonrec 'a t =
| Expansion of 'a
| String of string
end
module Partial : sig
type nonrec 'a t =
| Expansion of 'a
| String of string
| Unexpanded of t
end
module Partial : sig
type nonrec 'a t =
| Expanded of 'a
| Unexpanded of t
end
module Expand_to(V : EXPANSION) : sig
val expand
: V.context
-> t
-> f:(Loc.t -> string -> V.t option)
-> V.t Expand.Full.t
(** [expand t ~f] return [t] where all variables have been expanded
using [f]. If [f loc var] return [Some x], the variable [var] is
replaced by [x]; otherwise, the variable is inserted using the syntax
it was originally defined with: ${..} or $(..) *)
val expand
: t
-> mode:'a Mode.t
-> dir:Path.t
-> f:(Loc.t -> string -> Value.t list option)
-> 'a
val partial_expand
: V.context
-> t
-> f:(Loc.t -> string -> V.t option)
-> V.t Expand.Partial.t
(** [partial_expand t ~f] is like [expand_generic] where all
variables that could be expanded (i.e., those for which [f]
returns [Some _]) are. If all the variables of [t] were
expanded, a string is returned. If [f] returns [None] on at
least a variable of [t], it returns a string-with-vars. *)
end
val expand :
t -> f:(Loc.t -> string -> string option) -> string
(** Specialized version [Expand_to.expand] that returns a string (so
variables are assumed to expand to a single value). *)
val partial_expand :
t -> f:(Loc.t -> string -> string option) -> (string, t) Either.t
(** [partial_expand] is a specialized version of
[Expand_to.partial_expand] that returns a string. *)
val partial_expand
: t
-> mode:'a Mode.t
-> dir:Path.t
-> f:(Loc.t -> string -> Value.t list option)
-> 'a Partial.t

90
src/super_context.ml
View File

@ -45,7 +45,7 @@ type t =
; artifacts : Artifacts.t
; stanzas_to_consider_for_install : Installable.t list
; cxx_flags : string list
; vars : Action.Var_expansion.t String.Map.t
; vars : Value.t list String.Map.t
; chdir : (Action.t, Action.t) Build.t
; host : t option
; libs_by_package : (Package.t * Lib.Set.t) Package.Name.Map.t
@ -86,16 +86,25 @@ let find_scope_by_name t name = Scope.DB.find_by_name t.scopes name
let expand_var_no_root t var = String.Map.find t.vars var
let expand_vars t ~scope ~dir ?(extra_vars=String.Map.empty) s =
String_with_vars.expand s ~f:(fun _loc -> function
| "ROOT" -> Some (Path.reach ~from:dir t.context.build_dir)
| "SCOPE_ROOT" ->
Some (Path.reach ~from:dir (Scope.root scope))
| var ->
Option.map ~f:(fun e -> Action.Var_expansion.to_string dir e)
let (expand_vars, expand_vars_path) =
let expand t ~scope ~dir ?(extra_vars=String.Map.empty) s =
String_with_vars.expand ~mode:Single ~dir s ~f:(fun _loc -> function
| "ROOT" -> Some [Value.Path t.context.build_dir]
| "SCOPE_ROOT" -> Some [Value.Path (Scope.root scope)]
| var ->
(match expand_var_no_root t var with
| Some _ as x -> x
| None -> String.Map.find extra_vars var))
in
let expand_vars t ~scope ~dir ?extra_vars s =
expand t ~scope ~dir ?extra_vars s
|> Value.to_string ~dir
in
let expand_vars_path t ~scope ~dir ?extra_vars s =
expand t ~scope ~dir ?extra_vars s
|> Value.to_path ~error_loc:(String_with_vars.loc s) ~dir
in
(expand_vars, expand_vars_path)
let expand_and_eval_set t ~scope ~dir ?extra_vars set ~standard =
let open Build.O in
@ -270,18 +279,17 @@ let create
| None -> Path.relative context.ocaml_bin "ocamlopt"
| Some p -> p
in
let open Action.Var_expansion in
let string s = [Value.String s] in
let path p = [Value.Path p] in
let make =
match Bin.make with
| None -> Strings (["make"], Split)
| Some p -> Paths ([p], Split)
| None -> string "make"
| Some p -> path p
in
let cflags = context.ocamlc_cflags in
let strings l = Strings (l , Split) in
let string s = Strings ([s], Concat) in
let path p = Paths ([p], Split) in
let strings = Value.L.strings in
let vars =
[ "-verbose" , Strings ([] (*"-verbose";*), Concat)
[ "-verbose" , []
; "CPP" , strings (context.c_compiler :: cflags @ ["-E"])
; "PA_CPP" , strings (context.c_compiler :: cflags
@ ["-undef"; "-traditional";
@ -482,13 +490,11 @@ module Deps = struct
let make_alias t ~scope ~dir s =
let loc = String_with_vars.loc s in
Alias.of_user_written_path ~loc
(Path.relative ~error_loc:loc dir (expand_vars t ~scope ~dir s))
Alias.of_user_written_path ~loc ((expand_vars_path t ~scope ~dir s))
let dep t ~scope ~dir = function
| File s ->
let path = Path.relative ~error_loc:(String_with_vars.loc s) dir
(expand_vars t ~scope ~dir s) in
let path = expand_vars_path t ~scope ~dir s in
Build.path path
>>^ fun () -> [path]
| Alias s ->
@ -500,19 +506,17 @@ module Deps = struct
>>^ fun () -> []
| Glob_files s -> begin
let loc = String_with_vars.loc s in
let path =
Path.relative ~error_loc:loc dir (expand_vars t ~scope ~dir s) in
let path = expand_vars_path t ~scope ~dir s in
match Glob_lexer.parse_string (Path.basename path) with
| Ok re ->
let dir = Path.parent_exn path in
Build.paths_glob ~loc ~dir (Re.compile re)
>>^ Path.Set.to_list
| Error (_pos, msg) ->
Loc.fail loc "invalid glob: %s" msg
Loc.fail (String_with_vars.loc s) "invalid glob: %s" msg
end
| Files_recursively_in s ->
let path = Path.relative ~error_loc:(String_with_vars.loc s)
dir (expand_vars t ~scope ~dir s) in
let path = expand_vars_path t ~scope ~dir s in
Build.files_recursively_in ~dir:path ~file_tree:t.file_tree
>>^ Path.Set.to_list
| Package p ->
@ -588,7 +592,7 @@ module Action = struct
; (* Static deps from ${...} variables. For instance ${exe:...} *)
mutable sdeps : Path.Set.t
; (* Dynamic deps from ${...} variables. For instance ${read:...} *)
mutable ddeps : (unit, Action.Var_expansion.t) Build.t String.Map.t
mutable ddeps : (unit, Value.t list) Build.t String.Map.t
}
let add_lib_dep acc lib kind =
@ -602,8 +606,8 @@ module Action = struct
acc.ddeps <- String.Map.add acc.ddeps key dep;
None
let path_exp path = Action.Var_expansion.Paths ([path], Concat)
let str_exp path = Action.Var_expansion.Strings ([path], Concat)
let path_exp path = [Value.Path path]
let str_exp str = [Value.String str]
let map_exe sctx =
match sctx.host with
@ -630,7 +634,6 @@ module Action = struct
; ddeps = String.Map.empty
}
in
let open Action.Var_expansion in
let expand loc key var = function
| Some ("exe" , s) -> Some (path_exp (map_exe (Path.relative dir s)))
| Some ("path" , s) -> Some (path_exp (Path.relative dir s) )
@ -683,8 +686,8 @@ module Action = struct
| Some p ->
let x =
Pkg_version.read sctx p >>^ function
| None -> Strings ([""], Concat)
| Some s -> Strings ([s], Concat)
| None -> [Value.String ""]
| Some s -> [String s]
in
add_ddep acc ~key x
| None ->
@ -696,7 +699,7 @@ module Action = struct
let path = Path.relative dir s in
let data =
Build.contents path
>>^ fun s -> Strings ([s], Concat)
>>^ fun s -> [Value.String s]
in
add_ddep acc ~key data
end
@ -704,7 +707,7 @@ module Action = struct
let path = Path.relative dir s in
let data =
Build.lines_of path
>>^ fun l -> Strings (l, Split)
>>^ Value.L.strings
in
add_ddep acc ~key data
end
@ -712,7 +715,7 @@ module Action = struct
let path = Path.relative dir s in
let data =
Build.strings path
>>^ fun l -> Strings (l, Split)
>>^ Value.L.strings
in
add_ddep acc ~key data
end
@ -734,7 +737,7 @@ module Action = struct
match targets_written_by_user with
| Infer -> Loc.fail loc "You cannot use ${@} with inferred rules."
| Alias -> Loc.fail loc "You cannot use ${@} in aliases."
| Static l -> Some (Paths (l, Split))
| Static l -> Some (Value.L.paths l)
end
| _ ->
match String.lsplit2 var ~on:':' with
@ -742,16 +745,15 @@ module Action = struct
Some (path_exp (Path.relative dir s))
| x ->
let exp = expand loc key var x in
(match exp with
| Some (Paths (ps, _)) ->
acc.sdeps <- Path.Set.union (Path.Set.of_list ps) acc.sdeps
| _ -> ());
Option.iter exp ~f:(fun vs ->
acc.sdeps <- Path.Set.union (Path.Set.of_list
(Value.L.paths_only vs)) acc.sdeps;
);
exp)
in
(t, acc)
let expand_step2 ~dir ~dynamic_expansions ~deps_written_by_user ~map_exe t =
let open Action.Var_expansion in
U.Partial.expand t ~dir ~map_exe ~f:(fun loc key ->
match String.Map.find dynamic_expansions key with
| Some _ as opt -> opt
@ -762,12 +764,12 @@ module Action = struct
Some
(match deps_written_by_user with
| [] ->
Loc.warn loc "Variable '<' used with no explicit \
dependencies@.";
Strings ([""], Concat)
Loc.warn loc "Variable '<' used with no explicit \
dependencies@.";
[Value.String ""]
| dep :: _ ->
Paths ([dep], Concat))
| "^" -> Some (Paths (deps_written_by_user, Split))
[Path dep])
| "^" -> Some (Value.L.paths deps_written_by_user)
| _ -> None)
let run sctx ~loc ?(extra_vars=String.Map.empty)

14
src/super_context.mli
View File

@ -82,15 +82,23 @@ val expand_vars
: t
-> scope:Scope.t
-> dir:Path.t
-> ?extra_vars:Action.Var_expansion.t String.Map.t
-> ?extra_vars:Value.t list String.Map.t
-> String_with_vars.t
-> string
val expand_vars_path
: t
-> scope:Scope.t
-> dir:Path.t
-> ?extra_vars:Value.t list String.Map.t
-> String_with_vars.t
-> Path.t
val expand_and_eval_set
: t
-> scope:Scope.t
-> dir:Path.t
-> ?extra_vars:Action.Var_expansion.t String.Map.t
-> ?extra_vars:Value.t list String.Map.t
-> Ordered_set_lang.Unexpanded.t
-> standard:(unit, string list) Build.t
-> (unit, string list) Build.t
@ -224,7 +232,7 @@ module Action : sig
val run
: t
-> loc:Loc.t
-> ?extra_vars:Action.Var_expansion.t String.Map.t
-> ?extra_vars:Value.t list String.Map.t
-> Action.Unexpanded.t
-> dir:Path.t
-> dep_kind:Build.lib_dep_kind

34
src/value.ml Normal file
View File

@ -0,0 +1,34 @@
open Stdune
type t =
| String of string
| Path of Path.t
let string_of_path ~dir p = Path.reach ~from:dir p
let to_string t ~dir =
match t with
| String s -> s
| Path p -> string_of_path ~dir p
let to_path ?error_loc t ~dir =
match t with
| String s -> Path.relative ?error_loc dir s
| Path p -> p
module L = struct
let to_strings t ~dir = List.map t ~f:(to_string ~dir)
let concat ts ~dir =
List.map ~f:(to_string ~dir) ts
|> String.concat ~sep:" "
let paths_only =
List.filter_map ~f:(function
| String _ -> None
| Path p -> Some p)
let strings = List.map ~f:(fun x -> String x)
let paths = List.map ~f:(fun x -> Path x)
end

21
src/value.mli Normal file
View File

@ -0,0 +1,21 @@
open Stdune
type t =
| String of string
| Path of Path.t
val to_string : t -> dir:Path.t -> string
val to_path : ?error_loc:Loc.t -> t -> dir:Path.t -> Path.t
module L : sig
val strings : string list -> t list
val paths : Path.t list -> t list
val paths_only : t list -> Path.t list
val concat : t list -> dir:Path.t -> string
val to_strings : t list -> dir:Path.t -> string list
end

10
test/blackbox-tests/test-cases/misc/dune
View File

@ -1,13 +1,11 @@
(jbuild_version 1)
;; Test for ${^} with globs in rules
(rule
((targets (result expected))
(deps (jbuild (glob_files *.txt)))
(deps (dune (glob_files *.txt)))
(action (progn
(with-stdout-to result (echo ${^}))
(with-stdout-to expected (echo "jbuild a.txt b.txt c.txt"))))))
(with-stdout-to expected (echo "dune a.txt b.txt c.txt"))))))
(rule
((targets (result2 expected2))
@ -28,11 +26,11 @@
;; Test inferred rules
(rule (copy jbuild jbuild-plop))
(rule (copy dune dune-plop))
(alias
((name runtest)
(deps (jbuild jbuild-plop))
(deps (dune dune-plop))
(action (run diff -u ${^}))))
;; For some tests in subdirs

6
test/blackbox-tests/test-cases/misc/run.t
View File

@ -1,7 +1,7 @@
$ dune runtest --display short
File "dune", line 65, characters 21-44:
File "dune", line 63, characters 21-44:
Warning: Directory dir-that-doesnt-exist doesn't exist.
No rule found for jbuild
diff alias runtest
diff alias runtest
[1]
diff alias runtest
diff alias runtest

3
test/blackbox-tests/test-cases/quoting/quote-from-context/args Normal file
View File

@ -0,0 +1,3 @@
foo
bar
baz

3
test/blackbox-tests/test-cases/quoting/quote-from-context/count_args.ml Normal file
View File

@ -0,0 +1,3 @@
let () =
Printf.printf "Number of args: %d\n" (Array.length Sys.argv - 1)

6
test/blackbox-tests/test-cases/quoting/quote-from-context/dune Normal file
View File

@ -0,0 +1,6 @@
(executable
((name count_args)))
(alias
((name runtest)
(action (run ./count_args.exe ${read-lines:args}))))

4
test/blackbox-tests/test-cases/quoting/quotes-multi/dune Normal file
View File

@ -0,0 +1,4 @@
(alias
((name runtest)
(action (echo "lines: ${read-lines:foo}"))))

3
test/blackbox-tests/test-cases/quoting/quotes-multi/foo Normal file
View File

@ -0,0 +1,3 @@
foo
bar
baz

15
test/blackbox-tests/test-cases/quoting/run.t
View File

@ -3,12 +3,10 @@ that ${@} is not quoted and doesn't contain exactly 1 element
$ dune build --root bad x
Entering directory 'bad'
Error: Rule failed to generate the following targets:
- x
- y
File "dune", line 3, characters 26-30:
Error: Variable ${@} expands to 2 values, however a single value is expected here. Please quote this atom.
[1]
The targets should only be interpreted as a single path when quoted
$ dune build --root good s
@ -17,3 +15,12 @@ The targets should only be interpreted as a single path when quoted
- s
- t
[1]
$ dune runtest --root quote-from-context
Entering directory 'quote-from-context'
count_args alias runtest
Number of args: 3
$ dune runtest --root quotes-multi
Entering directory 'quotes-multi'
lines: foo bar baz