@ -1,5 +1,9 @@
# Define the list of system with their properties. Only systems tested for
# Nixpkgs are listed below
# Define the list of system with their properties.
#
# See https://clang.llvm.org/docs/CrossCompilation.html and
# http://llvm.org/docs/doxygen/html/Triple_8cpp_source.html especially
# Triple::normalize. Parsing should essentially act as a more conservative
# version of that last function.
with import ../lists.nix ;
with import ../types.nix ;
@ -23,7 +27,6 @@ rec {
littleEndian = { } ;
} ;
isCpuType = isType " c p u - t y p e " ;
cpuTypes = with significantBytes ; setTypesAssert " c p u - t y p e "
( x : elem x . bits [ 8 16 32 64 128 ]
@ -47,6 +50,7 @@ rec {
vendors = setTypes " v e n d o r " {
apple = { } ;
pc = { } ;
unknown = { } ;
} ;
@ -56,6 +60,7 @@ rec {
elf = { } ;
macho = { } ;
pe = { } ;
unknown = { } ;
} ;
@ -63,15 +68,12 @@ rec {
kernelFamilies = setTypes " k e r n e l - f a m i l y " {
bsd = { } ;
unix = { } ;
windows-nt = { } ;
dos = { } ;
} ;
isKernel = x : isType " k e r n e l " x ;
kernels = with execFormats ; with kernelFamilies ; setTypesAssert " k e r n e l "
( x : isExecFormat x . execFormat && all isKernelFamily ( attrValues x . families ) )
{
cygwin = { execFormat = pe ; families = { inherit /* u n i x */ windows-nt ; } ; } ;
darwin = { execFormat = macho ; families = { inherit unix ; } ; } ;
freebsd = { execFormat = elf ; families = { inherit unix bsd ; } ; } ;
linux = { execFormat = elf ; families = { inherit unix ; } ; } ;
@ -79,18 +81,21 @@ rec {
none = { execFormat = unknown ; families = { inherit unix ; } ; } ;
openbsd = { execFormat = elf ; families = { inherit unix bsd ; } ; } ;
solaris = { execFormat = elf ; families = { inherit unix ; } ; } ;
win32 = { execFormat = pe ; families = { inherit dos ; } ; } ;
windows = { execFormat = pe ; families = { } ; } ;
} // { # aliases
win32 = kernels . windows ;
} ;
isAbi = isType " a b i " ;
abis = setTypes " a b i " {
cygnus = { } ;
gnu = { } ;
msvc = { } ;
eabi = { } ;
androideabi = { } ;
gnueabi = { } ;
gnueabihf = { } ;
unknown = { } ;
} ;
@ -109,19 +114,25 @@ rec {
isDarwin = matchAttrs { kernel = kernels . darwin ; } ;
isLinux = matchAttrs { kernel = kernels . linux ; } ;
isUnix = matchAttrs { kernel = { families = { inherit ( kernelFamilies ) unix ; } ; } ; } ;
isWindows = s : matchAttrs { kernel = { families = { inherit ( kernelFamilies ) windows-nt ; } ; } ; } s
|| matchAttrs { kernel = { families = { inherit ( kernelFamilies ) dos ; } ; } ; } s ;
isWindows = matchAttrs { kernel = kernels . windows ; } ;
isCygwin = matchAttrs { kernel = kernels . windows ; abi = abis . cygnus ; } ;
isMinGW = matchAttrs { kernel = kernels . windows ; abi = abis . gnu ; } ;
mkSkeletonFromList = l : {
" 2 " = { cpu = elemAt l 0 ; kernel = elemAt l 1 ; } ;
" 4 " = { cpu = elemAt l 0 ; vendor = elemAt l 1 ; kernel = elemAt l 2 ; abi = elemAt l 3 ; } ;
" 2 " = # We only do 2-part hacks for things Nix already supports
if elemAt l 1 == " c y g w i n "
then { cpu = elemAt l 0 ; kernel = " w i n d o w s " ; abi = " c y g n u s " ; }
else { cpu = elemAt l 0 ; kernel = elemAt l 1 ; } ;
" 3 " = # Awkwards hacks, beware!
if elemAt l 1 == " a p p l e "
then { cpu = elemAt l 0 ; vendor = " a p p l e " ; kernel = elemAt l 2 ; }
else if ( elemAt l 1 == " l i n u x " ) || ( elemAt l 2 == " g n u " )
then { cpu = elemAt l 0 ; kernel = elemAt l 1 ; abi = elemAt l 2 ; }
else if ( elemAt l 2 == " m i n g w 3 2 " ) # autotools breaks on -gnu for window
then { cpu = elemAt l 0 ; vendor = elemAt l 1 ; kernel = " w i n d o w s " ; abi = " g n u " ; }
else throw " T a r g e t s p e c i f i c a t i o n w i t h 3 c o m p o n e n t s i s a m b i g u o u s " ;
" 4 " = { cpu = elemAt l 0 ; vendor = elemAt l 1 ; kernel = elemAt l 2 ; abi = elemAt l 3 ; } ;
} . ${ toString ( length l ) }
or ( throw " s y s t e m s t r i n g h a s i n v a l i d n u m b e r o f h y p h e n - s e p a r a t e d c o m p o n e n t s " ) ;
@ -134,18 +145,10 @@ rec {
, # Also inferred below
abi ? assert false ; null
} @ args : let
getCpu = name :
attrByPath [ name ] ( throw " U n k n o w n C P U t y p e : ${ name } " )
cpuTypes ;
getVendor = name :
attrByPath [ name ] ( throw " U n k n o w n v e n d o r : ${ name } " )
vendors ;
getKernel = name :
attrByPath [ name ] ( throw " U n k n o w n k e r n e l : ${ name } " )
kernels ;
getAbi = name :
attrByPath [ name ] ( throw " U n k n o w n A B I : ${ name } " )
abis ;
getCpu = name : cpuTypes . ${ name } or ( throw " U n k n o w n C P U t y p e : ${ name } " ) ;
getVendor = name : vendors . ${ name } or ( throw " U n k n o w n v e n d o r : ${ name } " ) ;
getKernel = name : kernels . ${ name } or ( throw " U n k n o w n k e r n e l : ${ name } " ) ;
getAbi = name : abis . ${ name } or ( throw " U n k n o w n A B I : ${ name } " ) ;
system = rec {
cpu = getCpu args . cpu ;
@ -166,7 +169,10 @@ rec {
mkSystemFromString = s : mkSystemFromSkeleton ( mkSkeletonFromList ( lib . splitString " - " s ) ) ;
doubleFromSystem = { cpu , vendor , kernel , abi , . . . }: " ${ cpu . name } - ${ kernel . name } " ;
doubleFromSystem = { cpu , vendor , kernel , abi , . . . }:
if vendor == kernels . windows && abi == abis . cygnus
then " ${ cpu . name } - c y g w i n "
else " ${ cpu . name } - ${ kernel . name } " ;
tripleFromSystem = { cpu , vendor , kernel , abi , . . . } @ sys : assert isSystem sys ; let
optAbi = lib . optionalString ( abi != abis . unknown ) " - ${ abi . name } " ;