Documentation
Download
Publications Mailing lists
Users and projects
Bugzilla
Browse sources
Changelog summary, verbose
|
OMake Home Documentation Download Publications Mailing lists Users and projects Bugzilla Browse sources Changelog summary, verbose |
Jump to version 0.9.8.5, 0.9.8.4, 0.9.8.3, 0.9.8.1, 0.9.8, 0.9.6.9, 0.9.6.8, 0.9.6.7, 0.9.6.6, 0.9.6.5, 0.9.6, 0.9.4, 0.9.3, 0.9.2.
See also the brief summary change log.
section
export
section
public.X = 1
println($X) # Prints 1
section
public.X = 1
public.Y = 2
export X
section
X = 3
Y = 4
export Y
# X is 3
# Y is 2
public.X = 1
public.f() =
X = 2
export
public.Y = $f
# X is 2
# Y is 2
Note: this is, of course, not the same as imperative programming, because
functions can always choose not to export. In particular, the string
"functions" do not export.
public.X = 1
export X
public.f() =
X = 2
Y = $"$f"
# X = 1
# Y = 2
.STATIC:
println(foo)
X = 1
Y = $X
The variable X is exported, with a "delayed" value. The rule is
only evaluated if the value for $X is needed, but it is lazy. The definition of Y does not force evaluation.
.STATIC: x.input
X = $(expensive-function x.input)
This is be evaluated if x.input changes and X is forced.
.STATIC: X: x.input
Y = 1
X = $Y
Here, Y is not exported from the section.
g(x) =
eprintln($"g($x)")
add($x, 1)
f(x) =
.STATIC: :key: $x
y = $(g $x)
value $y
println($(f 1))
println($(f 2))
println($(f 1))
will call function g twice - only once for each argument,
printing:
g(1)
2
g(2)
3
2
X. =
Y. =
Z. =
x = 1
X.Y.Z.y = 2
X.Y.Z.f() =
value $(add $x, $y)
echo $(X.Y.Z.f)
# prints "3"
X =
file([...])
a
b
c
- :
: Array
clean: %:
rm -f ...
Value dependencies are specified using the :value: option in rules.
a: b c :value: $(X)
...
This rule specifies that "a" should be recompiled if the value of $(X) changes (X does not have to be a filename). This is intended to allow greater control over dependencies. In addition, it can be used in place of other kinds of dependencies. For example, the following rule:
a: b :exists: c
commands
is the same as
a: b :value: $(target-exists c)
commands
Notes:
One other significant difference is that the rule cache now uses a digest of the rule commands text, not the text itself. This has an impact on initial omake speed (I am not sure how significant it is) but the cache is smaller. Also, "section eval" should now be handled correctly.
Externally, a .SCANNER rule has the usual rule form:
.SCANNER: target: dependencies...
...scanner commands...
However, the scanner target is now decoupled from the build target, allowing a scanner result to be used for multiple build targets. For example, ocamldep produces dependencies for .cmo and .cmx files simultaneously. They can share the scanner rule by specifying an explicit :scanner: dependency.
.SCANNER: scan-ocaml-%.ml: %.ml
ocamldep $lt;
%.cmo: %.ml :scanner: scan-ocaml-%.ml
$(OCAMLC) ...
%.cmx %.o: %.ml :scanner: scan-ocaml-%.ml
$(OCAMLOPT) ...
The current convention is that scanner targets should be named scan-<language>-<source-file>.
.SCANNER: foo:
echo "foo: boo"
foo: :scanner: foo
...
See documentation for the Target object and the "Examining the dependency graph" Section of the OMake Documentation for more information.
.SUBDIRS: foo boo
println(Current directory is $(CWD))
...normal configuration...
vmount(-l, src, x86)
.SUBDIRS: x86
Files from the src directory are now automatically linked into the x86 directory as needed. If you want to have multiple versions, you can use multiple directories (and multiple vmounts).
The keys are now "simple" values, not just strings. Simple values include integers, floats, strings, arrays of simple values, files, and directories.
Only the Map class has the map functions defined. If you want to have, say, a File that also includes a Map, create a subclass that extends both File and Map.
Literal string keys can be written in the form $|key...|. This works both for definitions and uses. The usual modifiers are allowed $,|key| and $`|key|.
X. =
extends $(Map)
$|key 1| = 1
$|key 2| = $|key 1| boo
$|key 2| += foo