1 /**
2 	Build settings definitions.
3 
4 	Copyright: © 2013-2014 rejectedsoftware e.K.
5 	License: Subject to the terms of the MIT license, as written in the included LICENSE.txt file.
6 	Authors: Sönke Ludwig
7 */
8 module dub.compilers.buildsettings;
9 
10 import dub.internal.vibecompat.inet.path;
11 
12 import dub.internal.configy.Attributes;
13 
14 import std.array : array;
15 import std.algorithm : filter, any;
16 import std.path : globMatch;
17 import std.typecons : BitFlags;
18 import std.algorithm.iteration : uniq;
19 import std.range : chain;
20 
21 /// BuildPlatform specific settings, like needed libraries or additional
22 /// include paths.
23 struct BuildSettings {
24 	import dub.internal.vibecompat.data.serialization : byName;
25 
26 	TargetType targetType;
27 	string targetPath;
28 	string targetName;
29 	string workingDirectory;
30 	string mainSourceFile;
31 	string[] dflags;
32 	string[] lflags;
33 	string[] libs;
34 	string[] linkerFiles;
35 	string[] sourceFiles;
36 	string[] injectSourceFiles;
37 	string[] copyFiles;
38 	string[] extraDependencyFiles;
39 	string[] versions;
40 	string[] debugVersions;
41 	string[] versionFilters;
42 	string[] debugVersionFilters;
43 	string[] importPaths;
44 	string[] stringImportPaths;
45 	string[] importFiles;
46 	string[] stringImportFiles;
47 	string[] preGenerateCommands;
48 	string[] postGenerateCommands;
49 	string[] preBuildCommands;
50 	string[] postBuildCommands;
51 	string[] preRunCommands;
52 	string[] postRunCommands;
53 	string[string] environments;
54 	string[string] buildEnvironments;
55 	string[string] runEnvironments;
56 	string[string] preGenerateEnvironments;
57 	string[string] postGenerateEnvironments;
58 	string[string] preBuildEnvironments;
59 	string[string] postBuildEnvironments;
60 	string[string] preRunEnvironments;
61 	string[string] postRunEnvironments;
62 	@byName Flags!BuildRequirement requirements;
63 	@byName Flags!BuildOption options;
64 
65 	BuildSettings dup()
66 	const {
67 		import std.traits: FieldNameTuple;
68 		import std.algorithm: map;
69 		import std.typecons: tuple;
70 		import std.array: assocArray;
71 		BuildSettings ret;
72 		foreach (m; FieldNameTuple!BuildSettings) {
73 			static if (is(typeof(__traits(getMember, ret, m) = __traits(getMember, this, m).dup)))
74 				__traits(getMember, ret, m) = __traits(getMember, this, m).dup;
75 			else static if (is(typeof(add(__traits(getMember, ret, m), __traits(getMember, this, m)))))
76 				add(__traits(getMember, ret, m), __traits(getMember, this, m));
77 			else static if (is(typeof(__traits(getMember, ret, m) = __traits(getMember, this, m))))
78 				__traits(getMember, ret, m) = __traits(getMember, this, m);
79 			else static assert(0, "Cannot duplicate BuildSettings." ~ m);
80 		}
81 		assert(ret.targetType == targetType);
82 		assert(ret.targetName == targetName);
83 		assert(ret.importPaths == importPaths);
84 		return ret;
85 	}
86 
87 	/**
88 	 * Merges $(LREF bs) onto `this` BuildSettings instance. This is called for
89 	 * sourceLibrary dependencies when they are included in the build to be
90 	 * merged into the root package build settings as well as configuring
91 	 * targets for different build types such as `release` or `unittest-cov`.
92 	 */
93 	void add(in BuildSettings bs)
94 	{
95 		addDFlags(bs.dflags);
96 		addLFlags(bs.lflags);
97 		addLibs(bs.libs);
98 		addLinkerFiles(bs.linkerFiles);
99 		addSourceFiles(bs.sourceFiles);
100 		addInjectSourceFiles(bs.injectSourceFiles);
101 		addCopyFiles(bs.copyFiles);
102 		addExtraDependencyFiles(bs.extraDependencyFiles);
103 		addVersions(bs.versions);
104 		addDebugVersions(bs.debugVersions);
105 		addVersionFilters(bs.versionFilters);
106 		addDebugVersionFilters(bs.debugVersionFilters);
107 		addImportPaths(bs.importPaths);
108 		addStringImportPaths(bs.stringImportPaths);
109 		addImportFiles(bs.importFiles);
110 		addStringImportFiles(bs.stringImportFiles);
111 		addPreGenerateCommands(bs.preGenerateCommands);
112 		addPostGenerateCommands(bs.postGenerateCommands);
113 		addPreBuildCommands(bs.preBuildCommands);
114 		addPostBuildCommands(bs.postBuildCommands);
115 		addPreRunCommands(bs.preRunCommands);
116 		addPostRunCommands(bs.postRunCommands);
117 		addEnvironments(bs.environments);
118 		addBuildEnvironments(bs.buildEnvironments);
119 		addRunEnvironments(bs.runEnvironments);
120 		addPreGenerateEnvironments(bs.preGenerateEnvironments);
121 		addPostGenerateEnvironments(bs.postGenerateEnvironments);
122 		addPreBuildEnvironments(bs.preBuildEnvironments);
123 		addPostBuildEnvironments(bs.postBuildEnvironments);
124 		addPreRunEnvironments(bs.preRunEnvironments);
125 		addPostRunEnvironments(bs.postRunEnvironments);
126 		addRequirements(bs.requirements);
127 		addOptions(bs.options);
128 	}
129 
130 	void addDFlags(in string[] value...) { dflags = chain(dflags, value.dup).uniq.array; }
131 	void prependDFlags(in string[] value...) { prepend(dflags, value); }
132 	void removeDFlags(in string[] value...) { remove(dflags, value); }
133 	void addLFlags(in string[] value...) { lflags ~= value; }
134 	void prependLFlags(in string[] value...) { prepend(lflags, value, false); }
135 	void addLibs(in string[] value...) { add(libs, value); }
136 	void addLinkerFiles(in string[] value...) { add(linkerFiles, value); }
137 	void addSourceFiles(in string[] value...) { add(sourceFiles, value); }
138 	void prependSourceFiles(in string[] value...) { prepend(sourceFiles, value); }
139 	void removeSourceFiles(in string[] value...) { removePaths(sourceFiles, value); }
140 	void addInjectSourceFiles(in string[] value...) { add(injectSourceFiles, value); }
141 	void addCopyFiles(in string[] value...) { add(copyFiles, value); }
142 	void addExtraDependencyFiles(in string[] value...) { add(extraDependencyFiles, value); }
143 	void addVersions(in string[] value...) { add(versions, value); }
144 	void addDebugVersions(in string[] value...) { add(debugVersions, value); }
145 	void addVersionFilters(in string[] value...) { add(versionFilters, value); }
146 	void addDebugVersionFilters(in string[] value...) { add(debugVersionFilters, value); }
147 	void addImportPaths(in string[] value...) { add(importPaths, value); }
148 	void addStringImportPaths(in string[] value...) { add(stringImportPaths, value); }
149 	void prependStringImportPaths(in string[] value...) { prepend(stringImportPaths, value); }
150 	void addImportFiles(in string[] value...) { add(importFiles, value); }
151 	void addStringImportFiles(in string[] value...) { addSI(stringImportFiles, value); }
152 	void addPreGenerateCommands(in string[] value...) { add(preGenerateCommands, value, false); }
153 	void addPostGenerateCommands(in string[] value...) { add(postGenerateCommands, value, false); }
154 	void addPreBuildCommands(in string[] value...) { add(preBuildCommands, value, false); }
155 	void addPostBuildCommands(in string[] value...) { add(postBuildCommands, value, false); }
156 	void addPreRunCommands(in string[] value...) { add(preRunCommands, value, false); }
157 	void addPostRunCommands(in string[] value...) { add(postRunCommands, value, false); }
158 	void addEnvironments(in string[string] value) { add(environments, value); }
159 	void updateEnvironments(in string[string] value) { update(environments, value); }
160 	void addBuildEnvironments(in string[string] value) { add(buildEnvironments, value); }
161 	void updateBuildEnvironments(in string[string] value) { update(buildEnvironments, value); }
162 	void addRunEnvironments(in string[string] value) { add(runEnvironments, value); }
163 	void updateRunEnvironments(in string[string] value) { update(runEnvironments, value); }
164 	void addPreGenerateEnvironments(in string[string] value) { add(preGenerateEnvironments, value); }
165 	void updatePreGenerateEnvironments(in string[string] value) { update(preGenerateEnvironments, value); }
166 	void addPostGenerateEnvironments(in string[string] value) { add(postGenerateEnvironments, value); }
167 	void updatePostGenerateEnvironments(in string[string] value) { update(postGenerateEnvironments, value); }
168 	void addPreBuildEnvironments(in string[string] value) { add(preBuildEnvironments, value); }
169 	void updatePreBuildEnvironments(in string[string] value) { update(preBuildEnvironments, value); }
170 	void addPostBuildEnvironments(in string[string] value) { add(postBuildEnvironments, value); }
171 	void updatePostBuildEnvironments(in string[string] value) { update(postBuildEnvironments, value); }
172 	void addPreRunEnvironments(in string[string] value) { add(preRunEnvironments, value); }
173 	void updatePreRunEnvironments(in string[string] value) { update(preRunEnvironments, value); }
174 	void addPostRunEnvironments(in string[string] value) { add(postRunEnvironments, value); }
175 	void updatePostRunEnvironments(in string[string] value) { update(postRunEnvironments, value); }
176 	void addRequirements(in BuildRequirement[] value...) { foreach (v; value) this.requirements |= v; }
177 	void addRequirements(in Flags!BuildRequirement value) { this.requirements |= value; }
178 	void addOptions(in BuildOption[] value...) { foreach (v; value) this.options |= v; }
179 	void addOptions(in Flags!BuildOption value) { this.options |= value; }
180 	void removeOptions(in BuildOption[] value...) { foreach (v; value) this.options &= ~v; }
181 	void removeOptions(in Flags!BuildOption value) { this.options &= ~value; }
182 
183 private:
184 	static auto filterDuplicates(T)(ref string[] arr, in T vals, bool noDuplicates = true)
185 	{
186 		return noDuplicates
187 			? vals.filter!(filtered => !arr.any!(item => item == filtered)).array
188 			: vals;
189 	}
190 
191 	// Append `vals` to `arr` without adding duplicates.
192 	static void add(ref string[] arr, in string[] vals, bool noDuplicates = true)
193 	{
194 		// vals might contain duplicates, add each val individually
195 		foreach (val; vals)
196 			arr ~= filterDuplicates(arr, [val], noDuplicates);
197 	}
198 	// Append `vals` to `aa`
199 	static void add(ref string[string] aa, in string[string] vals)
200 	{
201 		// vals might contain duplicated keys, add each val individually
202 		foreach (key, val; vals)
203 			if (key !in aa)
204 				aa[key] = val;
205 	}
206 	// Update `vals` to `aa`
207 	static void update(ref string[string] aa, in string[string] vals)
208 	{
209 		// If there are duplicate keys, they will be ignored and overwritten.
210 		foreach (key, val; vals)
211 			aa[key] = val;
212 	}
213 
214 	unittest
215 	{
216 		auto ary = ["-dip1000", "-vgc"];
217 		BuildSettings.add(ary, ["-dip1000", "-vgc"]);
218 		assert(ary == ["-dip1000", "-vgc"]);
219 		BuildSettings.add(ary, ["-dip1001", "-vgc"], false);
220 		assert(ary == ["-dip1000", "-vgc", "-dip1001", "-vgc"]);
221 		BuildSettings.add(ary, ["-dupflag", "-notdupflag", "-dupflag"]);
222 		assert(ary == ["-dip1000", "-vgc", "-dip1001", "-vgc", "-dupflag", "-notdupflag"]);
223 	}
224 
225 	// Prepend `arr` by `vals` without adding duplicates.
226 	static void prepend(ref string[] arr, in string[] vals, bool noDuplicates = true)
227 	{
228 		import std.range : retro;
229 		// vals might contain duplicates, add each val individually
230 		foreach (val; vals.retro)
231 			arr = filterDuplicates(arr, [val], noDuplicates) ~ arr;
232 	}
233 
234 	unittest
235 	{
236 		auto ary = ["-dip1000", "-vgc"];
237 		BuildSettings.prepend(ary, ["-dip1000", "-vgc"]);
238 		assert(ary == ["-dip1000", "-vgc"]);
239 		BuildSettings.prepend(ary, ["-dip1001", "-vgc"], false);
240 		assert(ary == ["-dip1001", "-vgc", "-dip1000", "-vgc"]);
241 		BuildSettings.prepend(ary, ["-dupflag", "-notdupflag", "-dupflag"]);
242 		assert(ary == ["-notdupflag", "-dupflag", "-dip1001", "-vgc", "-dip1000", "-vgc"]);
243 	}
244 
245 	// add string import files (avoids file name duplicates in addition to path duplicates)
246 	static void addSI(ref string[] arr, in string[] vals)
247 	{
248 		bool[string] existing;
249 		foreach (v; arr) existing[NativePath(v).head.name] = true;
250 		foreach (v; vals) {
251 			auto s = NativePath(v).head.name;
252 			if (s !in existing) {
253 				existing[s] = true;
254 				arr ~= v;
255 			}
256 		}
257 	}
258 
259 	unittest
260 	{
261 		auto ary = ["path/foo.txt"];
262 		BuildSettings.addSI(ary, ["path2/foo2.txt"]);
263 		assert(ary == ["path/foo.txt", "path2/foo2.txt"]);
264 		BuildSettings.addSI(ary, ["path2/foo.txt"]); // no duplicate basenames
265 		assert(ary == ["path/foo.txt", "path2/foo2.txt"]);
266 	}
267 
268 	static bool pathMatch(string path, string pattern)
269 	{
270 		import std.functional : memoize;
271 
272 		alias nativePath = memoize!((string stringPath) => NativePath(stringPath));
273 
274 		return nativePath(path) == nativePath(pattern) || globMatch(path, pattern);
275 	}
276 
277 	static void removeValuesFromArray(alias Match)(ref string[] arr, in string[] vals)
278 	{
279 		bool matches(string s)
280 		{
281 			return vals.any!(item => Match(s, item));
282 		}
283 		arr = arr.filter!(s => !matches(s)).array;
284 	}
285 
286 	static void removePaths(ref string[] arr, in string[] vals)
287 	{
288 		removeValuesFromArray!(pathMatch)(arr, vals);
289 	}
290 
291 	unittest
292 	{
293 		auto ary = ["path1", "root/path1", "root/path2", "root2/path1"];
294 		BuildSettings.removePaths(ary, ["path1"]);
295 		assert(ary == ["root/path1", "root/path2", "root2/path1"]);
296 		BuildSettings.removePaths(ary, ["*/path1"]);
297 		assert(ary == ["root/path2"]);
298 		BuildSettings.removePaths(ary, ["foo", "bar", "root/path2"]);
299 		assert(ary == []);
300 	}
301 
302 	static void remove(ref string[] arr, in string[] vals)
303 	{
304 		removeValuesFromArray!((a, b) => a == b)(arr, vals);
305 	}
306 
307 	unittest
308 	{
309 		import std.string : join;
310 
311 		auto ary = ["path1", "root/path1", "root/path2", "root2/path1"];
312 		BuildSettings.remove(ary, ["path1"]);
313 		assert(ary == ["root/path1", "root/path2", "root2/path1"]);
314 		BuildSettings.remove(ary, ["root/path*"]);
315 		assert(ary == ["root/path1", "root/path2", "root2/path1"]);
316 		BuildSettings.removePaths(ary, ["foo", "root/path2", "bar", "root2/path1"]);
317 		assert(ary == ["root/path1"]);
318 		BuildSettings.remove(ary, ["root/path1", "foo"]);
319 		assert(ary == []);
320 	}
321 }
322 
323 enum BuildSetting {
324 	dflags            = 1<<0,
325 	lflags            = 1<<1,
326 	libs              = 1<<2,
327 	sourceFiles       = 1<<3,
328 	copyFiles         = 1<<4,
329 	versions          = 1<<5,
330 	debugVersions     = 1<<6,
331 	importPaths       = 1<<7,
332 	stringImportPaths = 1<<8,
333 	options           = 1<<9,
334 	none = 0,
335 	commandLine = dflags|copyFiles,
336 	commandLineSeparate = commandLine|lflags,
337 	all = dflags|lflags|libs|sourceFiles|copyFiles|versions|debugVersions|importPaths|stringImportPaths|options,
338 	noOptions = all & ~options
339 }
340 
341 enum TargetType {
342 	autodetect,
343 	none,
344 	executable,
345 	library,
346 	sourceLibrary,
347 	dynamicLibrary,
348 	staticLibrary,
349 	object
350 }
351 
352 enum BuildRequirement {
353 	none = 0,                     /// No special requirements
354 	allowWarnings        = 1<<0,  /// Warnings do not abort compilation
355 	silenceWarnings      = 1<<1,  /// Don't show warnings
356 	disallowDeprecations = 1<<2,  /// Using deprecated features aborts compilation
357 	silenceDeprecations  = 1<<3,  /// Don't show deprecation warnings
358 	disallowInlining     = 1<<4,  /// Avoid function inlining, even in release builds
359 	disallowOptimization = 1<<5,  /// Avoid optimizations, even in release builds
360 	requireBoundsCheck   = 1<<6,  /// Always perform bounds checks
361 	requireContracts     = 1<<7,  /// Leave assertions and contracts enabled in release builds
362 	relaxProperties      = 1<<8,  /// DEPRECATED: Do not enforce strict property handling (-property)
363 	noDefaultFlags       = 1<<9,  /// Do not issue any of the default build flags (e.g. -debug, -w, -property etc.) - use only for development purposes
364 }
365 
366 enum BuildOption {
367 	none = 0,                     /// Use compiler defaults
368 	debugMode = 1<<0,             /// Compile in debug mode (enables contracts, -debug)
369 	releaseMode = 1<<1,           /// Compile in release mode (disables assertions and bounds checks, -release)
370 	coverage = 1<<2,              /// Enable code coverage analysis (-cov)
371 	debugInfo = 1<<3,             /// Enable symbolic debug information (-g)
372 	debugInfoC = 1<<4,            /// Enable symbolic debug information in C compatible form (-gc)
373 	alwaysStackFrame = 1<<5,      /// Always generate a stack frame (-gs)
374 	stackStomping = 1<<6,         /// Perform stack stomping (-gx)
375 	inline = 1<<7,                /// Perform function inlining (-inline)
376 	noBoundsCheck = 1<<8,         /// Disable all bounds checking (-noboundscheck)
377 	optimize = 1<<9,              /// Enable optimizations (-O)
378 	profile = 1<<10,              /// Emit profiling code (-profile)
379 	unittests = 1<<11,            /// Compile unit tests (-unittest)
380 	verbose = 1<<12,              /// Verbose compiler output (-v)
381 	ignoreUnknownPragmas = 1<<13, /// Ignores unknown pragmas during compilation (-ignore)
382 	syntaxOnly = 1<<14,           /// Don't generate object files (-o-)
383 	warnings = 1<<15,             /// Enable warnings (-wi)
384 	warningsAsErrors = 1<<16,     /// Treat warnings as errors (-w)
385 	ignoreDeprecations = 1<<17,   /// Do not warn about using deprecated features (-d)
386 	deprecationWarnings = 1<<18,  /// Warn about using deprecated features (-dw)
387 	deprecationErrors = 1<<19,    /// Stop compilation upon usage of deprecated features (-de)
388 	property = 1<<20,             /// DEPRECATED: Enforce property syntax (-property)
389 	profileGC = 1<<21,            /// Profile runtime allocations
390 	pic = 1<<22,                  /// Generate position independent code
391 	betterC = 1<<23,              /// Compile in betterC mode (-betterC)
392 	lowmem = 1<<24,               /// Compile in low-memory mode (-lowmem)
393 	coverageCTFE = 1<<25,         /// Enable code coverage analysis including at compile-time (-cov=ctfe)
394 	color = 1<<26,                /// Colorize output (-color)
395 
396 	// for internal usage
397 	_docs = 1<<27,                // Write ddoc to docs
398 	_ddox = 1<<28,                // Compile docs.json
399 }
400 
401 struct Flags (T) {
402 	import dub.internal.vibecompat.data.serialization : ignore;
403 
404 	@ignore BitFlags!T values;
405 
406 	public this(T opt) @safe pure nothrow @nogc
407 	{
408 		this.values = opt;
409 	}
410 
411 	public this(BitFlags!T v) @safe pure nothrow @nogc
412 	{
413 		this.values = v;
414 	}
415 
416 	alias values this;
417 
418 	/**
419 	 * Reads a list of flags from a JSON/YAML document and converts them
420 	 * to our internal representation.
421 	 *
422 	 * Flags inside of dub code are stored as a `BitFlags`,
423 	 * but they are specified in the recipe using an array of their name.
424 	 * This routine handles the conversion from `string[]` to `BitFlags!T`.
425 	 */
426 	public static Flags!T fromYAML (scope ConfigParser!(Flags!T) p)
427 	{
428 		import dub.internal.dyaml.node;
429 		import std.exception;
430 		import std.conv;
431 
432 		enforce(p.node.nodeID == NodeID.sequence, "Should be a sequence");
433 		typeof(return) res;
434 		foreach (str; p.node.sequence)
435 			res |= str.as!string.to!T;
436 		return res;
437 	}
438 }
439 
440 unittest
441 {
442 	import dub.internal.configy.Read;
443 
444 	static struct Config
445 	{
446 		Flags!BuildRequirement flags;
447 	}
448 
449 	auto c = parseConfigString!Config(`
450 {
451 	"flags": [ "allowWarnings", "noDefaultFlags", "disallowInlining" ]
452 }
453 `, __FILE__);
454 	assert(c.flags.allowWarnings);
455 	c.flags.allowWarnings = false;
456 	assert(c.flags.noDefaultFlags);
457 	c.flags.noDefaultFlags = false;
458 	assert(c.flags.disallowInlining);
459 	c.flags.disallowInlining = false;
460 	assert(c.flags == c.flags.init);
461 }
462 
463 /**
464 	All build options that will be inherited upwards in the dependency graph
465 
466 	Build options in this category fulfill one of the following properties:
467 	$(UL
468 		$(LI The option affects the semantics of the generated code)
469 		$(LI The option affects if a certain piece of code is valid or not)
470 		$(LI The option enabled meta information in dependent projects that are useful for the dependee (e.g. debug information))
471 	)
472 */
473 enum Flags!BuildOption inheritedBuildOptions =
474 	BuildOption.debugMode | BuildOption.releaseMode
475 	| BuildOption.coverage | BuildOption.coverageCTFE | BuildOption.debugInfo | BuildOption.debugInfoC
476 	| BuildOption.alwaysStackFrame | BuildOption.stackStomping | BuildOption.inline
477 	| BuildOption.noBoundsCheck | BuildOption.profile | BuildOption.ignoreUnknownPragmas
478 	| BuildOption.syntaxOnly | BuildOption.warnings	| BuildOption.warningsAsErrors
479 	| BuildOption.ignoreDeprecations | BuildOption.deprecationWarnings
480 	| BuildOption.deprecationErrors | BuildOption.property | BuildOption.profileGC
481 	| BuildOption.pic;
482 
483 deprecated("Use `Flags!BuildOption` instead")
484 public alias BuildOptions = Flags!BuildOption;
485 
486 deprecated("Use `Flags!BuildRequirement` instead")
487 public alias BuildRequirements = Flags!BuildRequirement;