forked from lix-project/lix
08c53923db
determination (e.g., finding the header files dependencies of a C
file) in Nix low-level builds automatically.
For instance, in the function `compileC' in make/lib/default.nix, we
find the header file dependencies of C file `main' as follows:
localIncludes =
dependencyClosure {
scanner = file:
import (findIncludes {
inherit file;
});
startSet = [main];
};
The function works by "growing" the set of dependencies, starting
with the set `startSet', and calling the function `scanner' for each
file to get its dependencies (which should yield a list of strings
representing relative paths). For instance, when `scanner' is
called on a file `foo.c' that includes the line
#include "../bar/fnord.h"
then `scanner' should yield ["../bar/fnord.h"]. This list of
dependencies is absolutised relative to the including file and added
to the set of dependencies. The process continues until no more
dependencies are found (hence its a closure).
`dependencyClosure' yields a list that contains in alternation a
dependency, and its relative path to the directory of the start
file, e.g.,
[ /bla/bla/foo.c
"foo.c"
/bla/bar/fnord.h
"../bar/fnord.h"
]
These relative paths are necessary for the builder that compiles
foo.c to reconstruct the relative directory structure expected by
foo.c.
The advantage of `dependencyClosure' over the old approach (using
the impure `__currentTime') is that it's completely pure, and more
efficient because it only rescans for dependencies (i.e., by
building the derivations yielded by `scanner') if sources have
actually changed. The old approach rescanned every time.
75 lines
1.9 KiB
Bash
75 lines
1.9 KiB
Bash
. $stdenv/setup
|
|
|
|
mainName=$(basename $main | cut -c34-)
|
|
|
|
echo "compiling \`$mainName'..."
|
|
|
|
# Turn $localIncludes into an array.
|
|
localIncludes=($localIncludes)
|
|
|
|
# Determine how many `..' levels appear in the header file references.
|
|
# E.g., if there is some reference `../../foo.h', then we have to
|
|
# insert two extra levels in the directory structure, so that `a.c' is
|
|
# stored at `dotdot/dotdot/a.c', and a reference from it to
|
|
# `../../foo.h' resolves to `dotdot/dotdot/../../foo.h' == `foo.h'.
|
|
n=0
|
|
maxDepth=0
|
|
for ((n = 0; n < ${#localIncludes[*]}; n += 2)); do
|
|
target=${localIncludes[$((n + 1))]}
|
|
|
|
# Split the target name into path components using some IFS magic.
|
|
savedIFS="$IFS"
|
|
IFS=/
|
|
components=($target)
|
|
depth=0
|
|
for ((m = 0; m < ${#components[*]}; m++)); do
|
|
c=${components[m]}
|
|
if test "$c" = ".."; then
|
|
depth=$((depth + 1))
|
|
fi
|
|
done
|
|
IFS="$savedIFS"
|
|
|
|
if test $depth -gt $maxDepth; then
|
|
maxDepth=$depth;
|
|
fi
|
|
done
|
|
|
|
# Create the extra levels in the directory hierarchy.
|
|
prefix=
|
|
for ((n = 0; n < maxDepth; n++)); do
|
|
prefix="dotdot/$prefix"
|
|
done
|
|
|
|
# Create symlinks to the header files.
|
|
for ((n = 0; n < ${#localIncludes[*]}; n += 2)); do
|
|
source=${localIncludes[n]}
|
|
target=${localIncludes[$((n + 1))]}
|
|
|
|
# Create missing directories. We use IFS magic to split the path
|
|
# into path components.
|
|
savedIFS="$IFS"
|
|
IFS=/
|
|
components=($prefix$target)
|
|
fullPath=(.)
|
|
for ((m = 0; m < ${#components[*]} - 1; m++)); do
|
|
fullPath=("${fullPath[@]}" ${components[m]})
|
|
if ! test -d "${fullPath[*]}"; then
|
|
mkdir "${fullPath[*]}"
|
|
fi
|
|
done
|
|
IFS="$savedIFS"
|
|
|
|
ln -sf $source $prefix$target
|
|
done
|
|
|
|
# Create a symlink to the main file.
|
|
if ! test "$(readlink $prefix$mainName)" = $main; then
|
|
ln -s $main $prefix$mainName
|
|
fi
|
|
|
|
mkdir $out
|
|
test "$prefix" && cd $prefix
|
|
ls -l
|
|
gcc -Wall $cFlags -c $mainName -o $out/$mainName.o
|