*.pico

/external/blake2/Makefile

/external/picosat/Makefile

/external/expat/Makefile

/external/linenoise/Makefile

/external/libucl/Makefile

/external/sqlite/Makefile

/external/sqlite/config.h

/tests/frontend/test_environment.sh

/mk/defs.mk

syntax(2)

test_suite("pkg")

include("tests/Kyuafile")

include @builddir@/mk/defs.mk

DIRS=	external compat libpkg/repo libpkg src docs scripts @testsdir@

include $(MK)/dir.mk

check: all

@if testsdir == "tests"

	if [ "$(HTML)" != "" ]; then \

		args="-r $(top_builddir)/res.db" ; \

	fi ; \

	kyua --config=none test $$args \

		--kyuafile='$(top_builddir)/Kyuafile' \

		--build-root='$(top_builddir)' || FAILED=1 ; \

	if [ "$(HTML)" != "" ]; then \

		kyua report-html --force $$args --output=$(HTML) ; \

		rm -f $(top_builddir)/res.db ; \

	fi ; \

	exit $${FAILED}

@endif

COCCI_ARGS=	-I ${top_srcdir} \

		-I /usr/include \

		-I /usr/local/include \

		-I ${top_srcdir}/compat \

		-I ${top_srcdir}/libpkg \

		-I ${top_srcdir}/src \

		-I ${top_srcdir}/external/expat/lib \

		-I ${top_srcdir}/external/libyaml/include \

		-I ${top_srcdir}/external/libucl/include \

		-I ${top_srcdir}/external/uthash \

		-I ${top_srcdir}/external/sqlite  \

		-I ${top_srcdir}/external/libelf

1cocci:

	spatch ${COCCI_ARGS} -in_place -sp_file $(top_srcdir)/tests/cocci/${COCCITEST} -dir ${top_srcdir}/libpkg ; \

	spatch ${COCCI_ARGS} -in_place -sp_file $(top_srcdir)/tests/cocci/${COCCITEST} -dir ${top_srcdir}/src ;

cocci:

	for c in ${top_srcdir}/tests/cocci/*.cocci ; do \

		echo "Passing $$c" ; \

		spatch ${COCCI_ARGS} -in_place -sp_file $$c -dir ${top_srcdir}/libpkg ; \

		spatch ${COCCI_ARGS} -in_place -sp_file $$c -dir ${top_srcdir}/src ; \

	done

# vim:se syn=tcl:

#

use cc cc-lib cc-shared pkg-config

set maj_ver 1

set med_ver 10

set min_ver 99

set dev_ver 8

define PKG_API [expr $maj_ver * 1000000 + $med_ver * 1000 + $min_ver]

define VERSION $maj_ver.$med_ver.$min_ver[expr {$dev_ver ? ".$dev_ver" : ""}]

# Add any user options here

options {

	pkgconfigdir:WHERE => "path to the directory where to install pc files"

	with-ldns => "add support for libldns"

	with-libarchive.pc => "build with libarchive getting flags via pc files"

}

if {[opt-str pkgconfigdir dir]} {

	define pkgconfigdir $dir

} else {

	if {[string match *-freebsd* [get-define host]]} {

		define pkgconfigdir [get-define prefix]/libdata/pkgconfig

	} else {

		define pkgconfigdir [get-define prefix]/lib/pkgconfig

	}

}

cc-check-tools ar ranlib strip

define EXTRA_LIBS ""

define LIBVERSION 4

define LIBSOEXT [format [get-define SH_SOEXTVER] [get-define LIBVERSION]]

define GITHASH ""

if {[cc-check-progs git] && [file exists .git]} {

	catch {exec git rev-parse --short HEAD} gitrev

	catch {exec git diff-index -m --name-only HEAD} gitdirty

	define GITHASH -$gitrev[expr {$gitdirty eq {} ? {} : {-dirty}}]

}

if {[string match *-linux* [get-define host]]} {

	cc-with { -libs { -lbsd }} {

		if {[cc-check-functions getprogname]} {

			define-append EXTRA_LIBS -lbsd

			define-feature libbsd

		} else {

			user-error "Unable to find libbsd"

		}

	}

}

if {![opt-bool with-libarchive.pc]} {

	cc-with { -libs { -larchive }} {

		if {![cc-check-functions archive_read_open]} {

			user-error "Unable to find libarchive"

		}

	}

}

cc-with { -libs { -lz }} {

	if {![cc-check-functions zlibVersion]} {

		user-error "Unable to find zlib"

	}

}

cc-with { -libs { -lbz2 }} {

	if {![cc-check-functions BZ2_bzReadOpen]} {

		user-error "Unable to find bzip2"

	}

}

cc-with { -libs { -llzma }} {

	if {![cc-check-functions lzma_version_string]} {

		user-error "Unable to find liblzma"

	}

}

# Atomics

msg-checking "Checking for atomic builtins... "

if {[cctest -code {

	volatile unsigned long val = 1;

	__sync_synchronize();

	__sync_val_compare_and_swap(&val, 1, 0);

	__sync_add_and_fetch(&val, 1);

	__sync_sub_and_fetch(&val, 1);

	return 0;

	}

]} {

	msg-result ok

	define-feature atomic_builtins

} else {

	msg-result no

	define-feature atomic_builtins 0

}

msg-checking "Checking for /proc/self/fd support... "

if {[file exists /proc/self/fd]} {

	msg-result ok

	define-feature proc-pid

} else {

	msg-result no

	define-feature proc-pid 0

}

lmap fct [list memmove usleep pread pwrite] {

	if {![cc-check-functions $fct]} {

		user-error "Cannot find $fct"

	}

}

cc-with { -includes fcntl.h } {

	cc-check-decls F_CLOSEM

}

cc-with { -includes sys/socket.h } {

	cc-check-decls SOCK_SEQPACKET

}

cc-with { -includes netinet/in.h } {

	cc-check-members "struct sockaddr_in.sin_len"

}

cc-with { -includes sys/stat.h } {

	cc-check-members "struct stat.st_mtim" "struct stat.st_flags"

}

# check for sqlite

cc-check-functions gmtime_r isnan localtime_r strchrnul strerror_r

cc-check-includes stdint.h inttypes.h

# check for pkg itself

cc-check-functions arc4random arc4random_stir basename_r chflagsat \

	closefrom dirfd eaccess fopencookie fstatfs funopen strnstr \

	strtofflags strtonum sysconf utimensat __res_setservers unlinkat \

	faccessat fstatat openat readlinkat fflagstostr

cc-with { -libs { -lutil }} {

	if {[cc-check-functions humanize_number]} {

		define-feature LIBUTIL

	}

}

cc-check-includes link.h machine/endian.h osreldate.h readpassphrase.h \

	sys/procctl.h sys/statfs.h sys/statvfs.h libutil.h

# for compat

cc-check-includes dirent.h

#endian stuff

lmap header [list endian.h sys/endian.h] {

	if {[cc-check-includes $header]} {

		cc-with [list -includes $header] {

			cc-check-decls be16dec be16enc be32dec be32enc be64dec be64enc \

				le16dec le16enc le32dec le32enc le64dec le64enc

		}

	}

}

if {[string match *-darwin* [get-define host]]} {

	define libabidir libmachista

} else {

# libelf

	cc-with { -includes { sys/types.h }} {

		cc-check-includes elf-hints.h sys/elf_common.h

	}

	if {[cc-check-includes gelf.h libelf.h]} {

		cc-with { -libs { -lelf } } {

			if {[cc-check-functions gelf_getehdr]} {

				define-feature libelf

				define-append EXTRA_LIBS -lelf

				define libabidir ""

			} else {

				define-feature libelf 0

				define libabidir "libelf"

			}

		}

	} else {

		define-feature libelf 0

		define libabidir "libelf"

	}

}

cc-with { -libs { -ljail} } {

	if {[cc-check-functions jail_getid]} {

		define-feature libjail

		define-append EXTRA_LIBS -ljail

	}

}

# libbsd

cc-check-includes bsd/err.h bsd/libutil.h bsd/readpassphrase.h \

	bsd/stdio.h bsd/strlib.h bsd/string.h bsd/sys/cdefs.h \

	bsd/unistd.h

# capsicum

if {[cc-check-functions cap_sandboxed]} {

	define-feature capsicum

	cc-check-includes sys/capsicum.h sys/capability.h

}

define testsdir ""

if {[pkg-config-init 0]} {

# atf

	if {[pkg-config atf-c] && [cc-check-progs kyua]} {

		define testsdir tests

		puts "test suite will be built"

	} else {

		puts "Skipping test suite"

	}

	if {[opt-bool with-ldns]} {

		if {![pkg-config libldns]} {

			user-error "Unable to find libldns"

		} else {

			define PKG_LIBDNS_LIBS_STATIC [exec pkg-config --static --libs-only-l libldns]

		}

	}

	if {[opt-bool with-libarchive.pc]} {

		if {![pkg-config libarchive]} {

			user-error "Unable to find libarchive"

		} else {

			define PKG_LIBARCHIVE_LIBS_STATIC [exec pkg-config --static --libs-only-l libarchive]

		}

	}

}

lmap repo [list binary] {

	define-append REPOS $repo

	define-append REPOS_LDFLAGS -L\$(top_builddir)/libpkg/repo/${repo} -lrepo-${repo}_pic

	define-append REPOS_STATIC_LIBS \$(top_builddir)/libpkg/repo/${repo}/librepo-${repo}.a

}

# ccache

if {[get-define CCACHE] ne {none}} {

  define CC "[get-define CCACHE] [get-define CC]"

}

make-config-header pkg_config.h

make-config-header external/sqlite/config.h

make-template mk/defs.mk.in

make-template libpkg/pkg.h.in

make-template libpkg/pkg.pc.in

make-template tests/frontend/test_environment.sh.in

make-template Makefile.autosetup Makefile

lmap dir [list external/expat external/blake2 external/picosat \

	external/linenoise external/libfetch external/sqlite \

	external compat libpkg libpkg/repo libpkg/repo/binary src \

	external/libucl external/libelf external/libmachista tests docs scripts] {

	make-template $dir/Makefile.autosetup $dir/Makefile

}

true

Unless explicitly stated, all files which form part of autosetup

are released under the following license:

---------------------------------------------------------------------

autosetup - A build environment "autoconfigurator"

Copyright (c) 2010-2011, WorkWare Systems <http://workware.net.au/>

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions

are met:

1. Redistributions of source code must retain the above copyright

   notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above

   copyright notice, this list of conditions and the following

   disclaimer in the documentation and/or other materials

   provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE WORKWARE SYSTEMS ``AS IS'' AND ANY

EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WORKWARE

SYSTEMS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,

INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The views and conclusions contained in the software and documentation

are those of the authors and should not be interpreted as representing

official policies, either expressed or implied, of WorkWare Systems.

README.autosetup created by autosetup v0.6.8

This is the autosetup directory for a local install of autosetup.

It contains autosetup, support files and loadable modules.

*.tcl files in this directory are optional modules which

can be loaded with the 'use' directive.

*.auto files in this directory are auto-loaded.

For more information, see http://msteveb.github.com/autosetup/

#!/bin/sh

# Copyright (c) 2006-2011 WorkWare Systems http://www.workware.net.au/

# All rights reserved

# vim:se syntax=tcl:

# \

dir=`dirname "$0"`; exec "`$dir/autosetup-find-tclsh`" "$0" "$@"

set autosetup(version) 0.6.8

# Can be set to 1 to debug early-init problems

set autosetup(debug) [expr {"--debug" in $argv}]

##################################################################

#

# Main flow of control, option handling

#

proc main {argv} {

	global autosetup define

	# There are 3 potential directories involved:

	# 1. The directory containing autosetup (this script)

	# 2. The directory containing auto.def

	# 3. The current directory

	# From this we need to determine:

	# a. The path to this script (and related support files)

	# b. The path to auto.def

	# c. The build directory, where output files are created

	# This is also complicated by the fact that autosetup may

	# have been run via the configure wrapper ([getenv WRAPPER] is set)

	# Here are the rules.

	# a. This script is $::argv0

	#    => dir, prog, exe, libdir

	# b. auto.def is in the directory containing the configure wrapper,

	#    otherwise it is in the current directory.

	#    => srcdir, autodef

	# c. The build directory is the current directory

	#    => builddir, [pwd]

	# 'misc' is needed before we can do anything, so set a temporary libdir

	# in case this is the development version

	set autosetup(libdir) [file dirname $::argv0]/lib

	use misc

	# (a)

	set autosetup(dir) [realdir [file dirname [realpath $::argv0]]]

	set autosetup(prog) [file join $autosetup(dir) [file tail $::argv0]]

	set autosetup(exe) [getenv WRAPPER $autosetup(prog)]

	if {$autosetup(installed)} {

		set autosetup(libdir) $autosetup(dir)

	} else {

		set autosetup(libdir) [file join $autosetup(dir) lib]

	}

	autosetup_add_dep $autosetup(prog)

	# (b)

	if {[getenv WRAPPER ""] eq ""} {

		# Invoked directly

		set autosetup(srcdir) [pwd]

	} else {

		# Invoked via the configure wrapper

		set autosetup(srcdir) [file-normalize [file dirname $autosetup(exe)]]

	}

	set autosetup(autodef) [relative-path $autosetup(srcdir)/auto.def]

	# (c)

	set autosetup(builddir) [pwd]

	set autosetup(argv) $argv

	set autosetup(cmdline) {}

	# options is a list of known options

	set autosetup(options) {}

	# optset is a dictionary of option values set by the user based on getopt

	set autosetup(optset) {}

	# optdefault is a dictionary of default values

	set autosetup(optdefault) {}

	# options-defaults is a dictionary of overrides for default values for options

	set autosetup(options-defaults) {}

	set autosetup(optionhelp) {}

	set autosetup(showhelp) 0

	# Parse options

	use getopt

	# At the is point we don't know what is a valid option

	# We simply parse anything that looks like an option

	set autosetup(getopt) [getopt argv]

	#"=Core Options:"

	options-add {

		help:=local  => "display help and options. Optionally specify a module name, such as --help=system"

		licence license => "display the autosetup license"

		version      => "display the version of autosetup"

		ref:=text manual:=text

		reference:=text => "display the autosetup command reference. 'text', 'wiki', 'asciidoc' or 'markdown'"

		debug        => "display debugging output as autosetup runs"

		install:=.   => "install autosetup to the current or given directory"

	}

	if {$autosetup(installed)} {

		# hidden options so we can produce a nice error

		options-add {

			sysinstall:path

		}

	} else {

		options-add {

			sysinstall:path  => "install standalone autosetup to the given directory (e.g.: /usr/local)"

		}

	}

	options-add {

		force init:=help   => "create initial auto.def, etc.  Use --init=help for known types"

		# Undocumented options

		option-checking=1

		nopager

		quiet

		timing

		conf:

	}

	if {[opt-bool version]} {

		puts $autosetup(version)

		exit 0

	}

	# autosetup --conf=alternate-auto.def

	if {[opt-str conf o]} {

		set autosetup(autodef) $o

	}

	# Debugging output (set this early)

	incr autosetup(debug) [opt-bool debug]

	incr autosetup(force) [opt-bool force]

	incr autosetup(msg-quiet) [opt-bool quiet]

	incr autosetup(msg-timing) [opt-bool timing]

	# If the local module exists, source it now to allow for

	# project-local customisations

	if {[file exists $autosetup(libdir)/local.tcl]} {

		use local

	}

	# Now any auto-load modules

	autosetup_load_auto_modules

	if {[opt-str help o]} {

		incr autosetup(showhelp)

		use help

		autosetup_help $o

	}

	if {[opt-bool licence license]} {

		use help

		autosetup_show_license

		exit 0

	}

	if {[opt-str {manual ref reference} o]} {

		use help

		autosetup_reference $o

	}

	# Allow combining --install and --init

	set earlyexit 0

	if {[opt-str install o]} {

		use install

		autosetup_install $o

		incr earlyexit

	}

	if {[opt-str init o]} {

		use init

		autosetup_init $o

		incr earlyexit

	}

	if {$earlyexit} {

		exit 0

	}

	if {[opt-str sysinstall o]} {

		use install

		autosetup_install $o 1

		exit 0

	}

	if {![file exists $autosetup(autodef)]} {

		# Check for invalid option first

		options {}

		user-error "No auto.def found in \"$autosetup(srcdir)\" (use [file tail $::autosetup(exe)] --init to create one)"

	}

	# Parse extra arguments into autosetup(cmdline)

	foreach arg $argv {

		if {[regexp {([^=]*)=(.*)} $arg -> n v]} {

			dict set autosetup(cmdline) $n $v

			define $n $v

		} else {

			user-error "Unexpected parameter: $arg"

		}

	}

	autosetup_add_dep $autosetup(autodef)

	define CONFIGURE_OPTS ""

	foreach arg $autosetup(argv) {

		define-append CONFIGURE_OPTS [quote-if-needed $arg]

	}

	define AUTOREMAKE [file-normalize $autosetup(exe)]

	define-append AUTOREMAKE [get-define CONFIGURE_OPTS]

	# Log how we were invoked

	configlog "Invoked as: [getenv WRAPPER $::argv0] [quote-argv $autosetup(argv)]"

	# Note that auto.def is *not* loaded in the global scope

	source $autosetup(autodef)

	# Could warn here if options {} was not specified

	show-notices

	if {$autosetup(debug)} {

		msg-result "Writing all defines to config.log"

		configlog "================ defines ======================"

		foreach n [lsort [array names define]] {

			configlog "define $n $define($n)"

		}

	}

	exit 0

}

# @opt-bool ?-nodefault? option ...

#

# Check each of the named, boolean options and if any have been explicitly enabled

# or disabled by the user, return 1 or 0 accordingly.

#

# If the option was specified more than once, the last value wins.

# e.g. With '--enable-foo --disable-foo', '[opt-bool foo]' will return 0

#

# If no value was specified by the user, returns the default value for the

# first option. If '-nodefault' is given, this behaviour changes and

# -1 is returned instead.

#

proc opt-bool {args} {

	set nodefault 0

	if {[lindex $args 0] eq "-nodefault"} {

		set nodefault 1

		set args [lrange $args 1 end]

	}

	option-check-names {*}$args

	foreach opt $args {

		if {[dict exists $::autosetup(optset) $opt]} {

			return [dict get $::autosetup(optset) $opt]

		}

	}

	if {$nodefault} {

		return -1

	}

	# Default value is the default for the first option

	return [dict get $::autosetup(optdefault) [lindex $args 0]]

}

# @opt-val optionlist ?default=""?

#

# Returns a list containing all the values given for the non-boolean options in '$optionlist'.

# There will be one entry in the list for each option given by the user, including if the

# same option was used multiple times.

#

# If no options were set, '$default' is returned (exactly, not as a list).

#

# Note: For most use cases, 'opt-str' should be preferred.

#

proc opt-val {names {default ""}} {

	option-check-names {*}$names

	foreach opt $names {

		if {[dict exists $::autosetup(optset) $opt]} {

			lappend result {*}[dict get $::autosetup(optset) $opt]

		}

	}

	if {[info exists result]} {

		return $result

	}

	return $default

}

# @opt-str optionlist varname ?default?

#

# Sets '$varname' in the callers scope to the value for one of the given options.

#

# For the list of options given in '$optionlist', if any value is set for any option,

# the option value is taken to be the *last* value of the last option (in the order given).

#

# If no option was given, and a default was specified with 'options-defaults',

# that value is used.

#

# If no 'options-defaults' value was given and '$default' was given, it is used.

#

# If none of the above provided a value, no value is set.

#

# The return value depends on whether '$default' was specified.

# If it was, the option value is returned.

# If it was not, 1 is returns if a value was set, or 0 if not.

#

# Typical usage is as follows:

#

## if {[opt-str {myopt altname} o]} {

##     do something with $o

## }

#

# Or:

## define myname [opt-str {myopt altname} o "/usr/local"]

#

proc opt-str {names varname args} {

	global autosetup

	option-check-names {*}$names

	upvar $varname value

	if {[llength $args]} {

		# A default was given, so always return the string value of the option

		set default [lindex $args 0]

		set retopt 1

	} else {

		# No default, so return 0 or 1 to indicate if a value was found

		set retopt 0

	}

	foreach opt $names {

		if {[dict exists $::autosetup(optset) $opt]} {

			set result [lindex [dict get $::autosetup(optset) $opt] end]

		}

	}

	if {![info exists result]} {

		# No user-specified value. Has options-defaults been set?

		foreach opt $names {

			if {[dict exists $::autosetup(options-defaults) $opt]} {

				set result [dict get $autosetup(options-defaults) $opt]

			}

		}

	}

	if {[info exists result]} {

		set value $result

		if {$retopt} {

			return $value

		}

		return 1

	}

	if {$retopt} {

		set value $default

		return $value

	}

	return 0

}

proc option-check-names {args} {

	foreach o $args {

		if {$o ni $::autosetup(options)} {

			autosetup-error "Request for undeclared option --$o"

		}

	}

}

# Parse the option definition in $opts and update

# ::autosetup(setoptions) and ::autosetup(optionhelp) appropriately

#

proc options-add {opts {header ""}} {

	global autosetup

	# First weed out comment lines

	set realopts {}

	foreach line [split $opts \n] {

		if {![string match "#*" [string trimleft $line]]} {

			append realopts $line \n

		}

	}

	set opts $realopts

	for {set i 0} {$i < [llength $opts]} {incr i} {

		set opt [lindex $opts $i]

		if {[string match =* $opt]} {

			# This is a special heading

			lappend autosetup(optionhelp) $opt ""

			set header {}

			continue

		}

		unset -nocomplain defaultvalue equal value

		#puts "i=$i, opt=$opt"

		regexp {^([^:=]*)(:)?(=)?(.*)$} $opt -> name colon equal value

		if {$name in $autosetup(options)} {

			autosetup-error "Option $name already specified"

		}

		#puts "$opt => $name $colon $equal $value"

		# Find the corresponding value in the user options

		# and set the default if necessary

		if {[string match "-*" $opt]} {

			# This is a documentation-only option, like "-C <dir>"

			set opthelp $opt

		} elseif {$colon eq ""} {

			# Boolean option

			lappend autosetup(options) $name

			# Check for override

			if {[dict exists $autosetup(options-defaults) $name]} {

				# A default was specified with options-defaults, so use it

				set value [dict get $autosetup(options-defaults) $name]

			}

			if {$value eq "1"} {

				set opthelp "--disable-$name"

			} else {

				set opthelp "--$name"

			}

			# Set the default

			if {$value eq ""} {

				set value 0

			}

			set defaultvalue $value

			dict set autosetup(optdefault) $name $defaultvalue

			if {[dict exists $autosetup(getopt) $name]} {

				# The option was specified by the user. Look at the last value.

				lassign [lindex [dict get $autosetup(getopt) $name] end] type setvalue

				if {$type eq "str"} {

					# Can we convert the value to a boolean?

					if {$setvalue in {1 enabled yes}} {

						set setvalue 1

					} elseif {$setvalue in {0 disabled no}} {

						set setvalue 0

					} else {

						user-error "Boolean option $name given as --$name=$setvalue"

					}

				}

				dict set autosetup(optset) $name $setvalue

				#puts "Found boolean option --$name=$setvalue"

			}

		} else {

			# String option.

			lappend autosetup(options) $name

			if {$colon eq ":"} {

				# Was ":name=default" given?

				# If so, set $value to the display name and $defaultvalue to the default

				# (This is the preferred way to set a default value for a string option)

				if {[regexp {^([^=]+)=(.*)$} $value -> value defaultvalue]} {

					dict set autosetup(optdefault) $name $defaultvalue

				}

			}

			# Maybe override the default value

			if {[dict exists $autosetup(options-defaults) $name]} {

				# A default was specified with options-defaults, so use it

				set defaultvalue [dict get $autosetup(options-defaults) $name]

				dict set autosetup(optdefault) $name $defaultvalue

			} elseif {![info exists defaultvalue]} {

				# For backward compatiblity, if ":name" was given, use name as both

				# the display text and the default value, but only if the user

				# specified the option without the value

				set defaultvalue $value

			}

			if {$equal eq "="} {

				# String option with optional value

				set opthelp "--$name?=$value?"

			} else {

				# String option with required value

				set opthelp "--$name=$value"

			}

			# Get the values specified by the user

			if {[dict exists $autosetup(getopt) $name]} {

				set listvalue {}

				foreach pair [dict get $autosetup(getopt) $name] {

					lassign $pair type setvalue

					if {$type eq "bool" && $setvalue} {

						if {$equal ne "="} {

							user-error "Option --$name requires a value"

						}

						# If given as a boolean, use the default value

						set setvalue $defaultvalue

					}

					lappend listvalue $setvalue

				}

				#puts "Found string option --$name=$listvalue"

				dict set autosetup(optset) $name $listvalue

			}

		}

		# Now create the help for this option if appropriate

		if {[lindex $opts $i+1] eq "=>"} {

			set desc [lindex $opts $i+2]

			if {[info exists defaultvalue]} {

				set desc [string map [list @default@ $defaultvalue] $desc]

			}

			#string match \n* $desc

			if {$header ne ""} {

				lappend autosetup(optionhelp) $header ""

				set header ""

			}

			# A multi-line description

			lappend autosetup(optionhelp) $opthelp $desc

			incr i 2

		}

	}

}

# @module-options optionlist

#

# Like 'options', but used within a module.

proc module-options {opts} {

	set header ""

	if {$::autosetup(showhelp) > 1 && [llength $opts]} {

		set header "Module Options:"

	}

	options-add $opts $header

	if {$::autosetup(showhelp)} {

		# Ensure that the module isn't executed on --help

		# We are running under eval or source, so use break

		# to prevent further execution

		#return -code break -level 2

		return -code break

	}

}

proc max {a b} {

	expr {$a > $b ? $a : $b}

}

proc options-wrap-desc {text length firstprefix nextprefix initial} {

	set len $initial

	set space $firstprefix

	foreach word [split $text] {

		set word [string trim $word]

		if {$word == ""} {

			continue

		}

		if {$len && [string length $space$word] + $len >= $length} {

			puts ""

			set len 0

			set space $nextprefix

		}

		incr len [string length $space$word]

		puts -nonewline $space$word

		set space " "

	}

	if {$len} {

		puts ""

	}

}

proc options-show {} {

	# Determine the max option width

	set max 0

	foreach {opt desc} $::autosetup(optionhelp) {

		if {[string match =* $opt] || [string match \n* $desc]} {

			continue

		}

		set max [max $max [string length $opt]]

	}

	set indent [string repeat " " [expr $max+4]]

	set cols [getenv COLUMNS 80]

	catch {

		lassign [exec stty size] rows cols

	}

	incr cols -1

	# Now output

	foreach {opt desc} $::autosetup(optionhelp) {

		if {[string match =* $opt]} {

			puts [string range $opt 1 end]

			continue

		}

		puts -nonewline "  [format %-${max}s $opt]"

		if {[string match \n* $desc]} {

			puts $desc

		} else {

			options-wrap-desc [string trim $desc] $cols "  " $indent [expr $max + 2]

		}

	}

}

# @options optionspec

#

# Specifies configuration-time options which may be selected by the user

# and checked with 'opt-str' and 'opt-bool'. '$optionspec' contains a series

# of options specifications separated by newlines, as follows:

#

# A boolean option is of the form:

#

## name[=0|1]  => "Description of this boolean option"

#

# The default is 'name=0', meaning that the option is disabled by default.

# If 'name=1' is used to make the option enabled by default, the description should reflect

# that with text like "Disable support for ...".

#

# An argument option (one which takes a parameter) is of the form:

#

## name:[=]value  => "Description of this option"

#

# If the 'name:value' form is used, the value must be provided with the option (as '--name=myvalue').

# If the 'name:=value' form is used, the value is optional and the given value is used as the default

# if it is not provided.

#

# The description may contain '@default@', in which case it will be replaced with the default

# value for the option (taking into account defaults specified with 'options-defaults'.

#

# Undocumented options are also supported by omitting the '=> description'.

# These options are not displayed with '--help' and can be useful for internal options or as aliases.

#

# For example, '--disable-lfs' is an alias for '--disable=largefile':

#

## lfs=1 largefile=1 => "Disable large file support"

#

proc options {optlist} {

	# Allow options as a list or args

	options-add $optlist "Local Options:"

	if {$::autosetup(showhelp)} {

		options-show

		exit 0

	}

	# Check for invalid options

	if {[opt-bool option-checking]} {

		foreach o [dict keys $::autosetup(getopt)] {

			if {$o ni $::autosetup(options)} {

				user-error "Unknown option --$o"

			}

		}

	}

}

# @options-defaults dictionary

#

# Specifies a dictionary of options and a new default value for each of those options.

# Use before any 'use' statements in 'auto.def' to change the defaults for

# subsequently included modules.

proc options-defaults {dict} {

	foreach {n v} $dict {

		dict set ::autosetup(options-defaults) $n $v

	}

}

proc config_guess {} {

	if {[file-isexec $::autosetup(dir)/autosetup-config.guess]} {

		if {[catch {exec-with-stderr sh $::autosetup(dir)/autosetup-config.guess} alias]} {

			user-error $alias

		}

		return $alias

	} else {

		configlog "No autosetup-config.guess, so using uname"

		string tolower [exec uname -p]-unknown-[exec uname -s][exec uname -r]

	}

}

proc config_sub {alias} {

	if {[file-isexec $::autosetup(dir)/autosetup-config.sub]} {

		if {[catch {exec-with-stderr sh $::autosetup(dir)/autosetup-config.sub $alias} alias]} {

			user-error $alias

		}

	}

	return $alias

}

# @define name ?value=1?

#

# Defines the named variable to the given value.

# These (name, value) pairs represent the results of the configuration check

# and are available to be subsequently checked, modified and substituted.

#

proc define {name {value 1}} {

	set ::define($name) $value

	#dputs "$name <= $value"

}

# @undefine name

#

# Undefine the named variable.

#

proc undefine {name} {

	unset -nocomplain ::define($name)

	#dputs "$name <= <undef>"

}

# @define-append name value ...

#

# Appends the given value(s) to the given "defined" variable.

# If the variable is not defined or empty, it is set to '$value'.

# Otherwise the value is appended, separated by a space.

# Any extra values are similarly appended.

# If any value is already contained in the variable (as a substring) it is omitted.

#

proc define-append {name args} {

	if {[get-define $name ""] ne ""} {

		# Avoid duplicates

		foreach arg $args {

			set found 0

			foreach str [split $::define($name) " "] {

				if {$str eq $arg} {

					incr found

				}

			}

			if {!$found} {

				append ::define($name) " " $arg

			}

		}

	} else {

		set ::define($name) [join $args]

	}

	#dputs "$name += [join $args] => $::define($name)"

}

# @get-define name ?default=0?

#

# Returns the current value of the "defined" variable, or '$default'

# if not set.

#

proc get-define {name {default 0}} {

	if {[info exists ::define($name)]} {

		#dputs "$name => $::define($name)"

		return $::define($name)

	}

	#dputs "$name => $default"

	return $default

}

# @is-defined name

#

# Returns 1 if the given variable is defined.

#

proc is-defined {name} {

	info exists ::define($name)

}

# @all-defines

#

# Returns a dictionary (name, value list) of all defined variables.

#

# This is suitable for use with 'dict', 'array set' or 'foreach'

# and allows for arbitrary processing of the defined variables.

#

proc all-defines {} {

	array get ::define

}

# @get-env name default

#

# If '$name' was specified on the command line, return it.

# Otherwise if '$name' was set in the environment, return it.

# Otherwise return '$default'.

#

proc get-env {name default} {

	if {[dict exists $::autosetup(cmdline) $name]} {

		return [dict get $::autosetup(cmdline) $name]

	}

	getenv $name $default

}

# @env-is-set name

#

# Returns 1 if '$name' was specified on the command line or in the environment.

# Note that an empty environment variable is not considered to be set.

#

proc env-is-set {name} {

	if {[dict exists $::autosetup(cmdline) $name]} {

		return 1

	}

	if {[getenv $name ""] ne ""} {

		return 1

	}

	return 0

}

# @readfile filename ?default=""?

#

# Return the contents of the file, without the trailing newline.

# If the file doesn't exist or can't be read, returns '$default'.

#

proc readfile {filename {default_value ""}} {

	set result $default_value

	catch {

		set f [open $filename]

		set result [read -nonewline $f]

		close $f

	}

	return $result

}

# @writefile filename value

#

# Creates the given file containing '$value'.

# Does not add an extra newline.

#

proc writefile {filename value} {

	set f [open $filename w]

	puts -nonewline $f $value

	close $f

}

proc quote-if-needed {str} {

	if {[string match {*[\" ]*} $str]} {

		return \"[string map [list \" \\" \\ \\\\] $str]\"

	}

	return $str

}

proc quote-argv {argv} {

	set args {}

	foreach arg $argv {

		lappend args [quote-if-needed $arg]

	}

	join $args

}

# @list-non-empty list

#

# Returns a copy of the given list with empty elements removed

proc list-non-empty {list} {

	set result {}

	foreach p $list {

		if {$p ne ""} {

			lappend result $p

		}

	}

	return $result

}

# @find-executable-path name

#

# Searches the path for an executable with the given name.

# Note that the name may include some parameters, e.g. 'cc -mbig-endian',

# in which case the parameters are ignored.

# The full path to the executable if found, or "" if not found.

# Returns 1 if found, or 0 if not.

#

proc find-executable-path {name} {

	# Ignore any parameters

	set name [lindex $name 0]

	# The empty string is never a valid executable

	if {$name ne ""} {

		foreach p [split-path] {

			dputs "Looking for $name in $p"

			set exec [file join $p $name]

			if {[file-isexec $exec]} {

				dputs "Found $name -> $exec"

				return $exec

			}

		}

	}

	return {}

}

# @find-executable name

#

# Searches the path for an executable with the given name.

# Note that the name may include some parameters, e.g. 'cc -mbig-endian',

# in which case the parameters are ignored.

# Returns 1 if found, or 0 if not.

#

proc find-executable {name} {

	if {[find-executable-path $name] eq {}} {

		return 0

	}

	return 1

}

# @find-an-executable ?-required? name ...

#

# Given a list of possible executable names,

# searches for one of these on the path.

#

# Returns the name found, or "" if none found.

# If the first parameter is '-required', an error is generated

# if no executable is found.

#

proc find-an-executable {args} {

	set required 0

	if {[lindex $args 0] eq "-required"} {

		set args [lrange $args 1 end]

		incr required

	}

	foreach name $args {

		if {[find-executable $name]} {

			return $name

		}

	}

	if {$required} {

		if {[llength $args] == 1} {

			user-error "failed to find: [join $args]"

		} else {

			user-error "failed to find one of: [join $args]"

		}

	}

	return ""

}

# @configlog msg

#

# Writes the given message to the configuration log, 'config.log'.

#

proc configlog {msg} {

	if {![info exists ::autosetup(logfh)]} {

		set ::autosetup(logfh) [open config.log w]

	}

	puts $::autosetup(logfh) $msg

}

# @msg-checking msg

#

# Writes the message with no newline to stdout.

#

proc msg-checking {msg} {

	if {$::autosetup(msg-quiet) == 0} {

		maybe-show-timestamp

		puts -nonewline $msg

		set ::autosetup(msg-checking) 1

	}

}

# @msg-result msg

#

# Writes the message to stdout.

#

proc msg-result {msg} {

	if {$::autosetup(msg-quiet) == 0} {

		maybe-show-timestamp

		puts $msg

		set ::autosetup(msg-checking) 0

		show-notices

	}

}

# @msg-quiet command ...

#

# 'msg-quiet' evaluates it's arguments as a command with output

# from 'msg-checking' and 'msg-result' suppressed.

#

# This is useful if a check needs to run a subcheck which isn't

# of interest to the user.

proc msg-quiet {args} {

	incr ::autosetup(msg-quiet)

	set rc [uplevel 1 $args]

	incr ::autosetup(msg-quiet) -1

	return $rc

}

# Will be overridden by 'use misc'

proc error-stacktrace {msg} {

	return $msg

}

proc error-location {msg} {

	return $msg

}

##################################################################

#

# Debugging output

#

proc dputs {msg} {

	if {$::autosetup(debug)} {

		puts $msg

	}

}

##################################################################

#

# User and system warnings and errors

#

# Usage errors such as wrong command line options

# @user-error msg

#

# Indicate incorrect usage to the user, including if required components

# or features are not found.

# 'autosetup' exits with a non-zero return code.

#

proc user-error {msg} {

	show-notices

	puts stderr "Error: $msg"

	puts stderr "Try: '[file tail $::autosetup(exe)] --help' for options"

	exit 1

}

# @user-notice msg

#

# Output the given message to stderr.

#

proc user-notice {msg} {

	lappend ::autosetup(notices) $msg

}

# Incorrect usage in the auto.def file. Identify the location.

proc autosetup-error {msg} {

	autosetup-full-error [error-location $msg]

}

# Like autosetup-error, except $msg is the full error message.

proc autosetup-full-error {msg} {

	show-notices

	puts stderr $msg

	exit 1

}

proc show-notices {} {

	if {$::autosetup(msg-checking)} {

		puts ""

		set ::autosetup(msg-checking) 0

	}

	flush stdout

	if {[info exists ::autosetup(notices)]} {

		puts stderr [join $::autosetup(notices) \n]

		unset ::autosetup(notices)

	}

}

proc maybe-show-timestamp {} {

	if {$::autosetup(msg-timing) && $::autosetup(msg-checking) == 0} {

		puts -nonewline [format {[%6.2f] } [expr {([clock millis] - $::autosetup(start)) % 10000 / 1000.0}]]

	}

}

# @autosetup-require-version required

#

# Checks the current version of 'autosetup' against '$required'.

# A fatal error is generated if the current version is less than that required.

#

proc autosetup-require-version {required} {

	use util

	if {[compare-versions $::autosetup(version) $required] < 0} {

		user-error "autosetup version $required is required, but this is $::autosetup(version)"

	}

}

proc autosetup_version {} {

	return "autosetup v$::autosetup(version)"

}

##################################################################

#

# Directory/path handling

#

proc realdir {dir} {

	set oldpwd [pwd]

	cd $dir

	set pwd [pwd]

	cd $oldpwd

	return $pwd

}

# Follow symlinks until we get to something which is not a symlink

proc realpath {path} {

	while {1} {

		if {[catch {

			set path [file readlink $path]

		}]} {

			# Not a link

			break

		}

	}

	return $path

}

# Convert absolute path, $path into a path relative

# to the given directory (or the current dir, if not given).

#

proc relative-path {path {pwd {}}} {

	set diff 0