f3728100d9
prefixing This adds an API to set optimization options externally,
providing an alternative and general solution for the non-portable
run-time tests used by the ARM Neon code. It also makes those tests
compile and link on Android.
The order of settings vs options in pnglibconf.h is reversed to allow
settings to depend on options and options can now set (or override) the
defaults for settings.
894 lines
31 KiB
Awk
Executable File
894 lines
31 KiB
Awk
Executable File
#!/bin/awk -f
|
|
# scripts/options.awk - library build configuration control
|
|
#
|
|
# last changed in libpng version 1.5.7 - December 15, 2011
|
|
#
|
|
# Copyright (c) 1998-2011 Glenn Randers-Pehrson
|
|
#
|
|
# This code is released under the libpng license.
|
|
# For conditions of distribution and use, see the disclaimer
|
|
# and license in png.h
|
|
|
|
# The output of this script is written to the file given by
|
|
# the variable 'out'. The script is run twice, once with
|
|
# an intermediate output file, 'options.tmp' then again on
|
|
# that file to produce the final output:
|
|
#
|
|
# awk -f scripts/options.awk out=options.tmp scripts/options.dfa 1>&2
|
|
# awk -f scripts/options.awk out=options.dfn options.tmp 1>&2
|
|
#
|
|
# Some options may be specified on the command line:
|
|
#
|
|
# deb=1 Causes debugging to be output
|
|
# logunsupported=1 Causes all options to be recorded in the output
|
|
# everything=off Causes all options to be disabled by default
|
|
# everything=on Causes all options to be enabled by default
|
|
#
|
|
# If awk fails on your platform, try nawk instead.
|
|
#
|
|
# These options may also be specified in the original input file (and
|
|
# are copied to the preprocessed file).
|
|
|
|
BEGIN{
|
|
out="" # intermediate, preprocessed, file
|
|
pre=-1 # preprocess (first line)
|
|
version="libpng version unknown" # version information
|
|
version_file="" # where to find the version
|
|
err=0 # in-line exit sets this
|
|
# The following definitions prevent the C preprocessor noticing the lines
|
|
# that will be in the final output file. Some C preprocessors tokenise
|
|
# the lines, for example by inserting spaces around operators, and all
|
|
# C preprocessors notice lines that start with '#', most remove comments.
|
|
# The technique adopted here is to make the final output lines into
|
|
# C strings (enclosed in double quotes), preceeded by PNG_DFN. As a
|
|
# consequence the output cannot contain a 'raw' double quote - instead put
|
|
# @' in, this will be replaced by a single " afterward. See the parser
|
|
# script dfn.awk for more capabilities (not required here). Note that if
|
|
# you need a " in a 'setting' in pnglibconf.dfa it must also be @'!
|
|
dq="@'" # For a single double quote
|
|
start=" PNG_DFN \"" # Start stuff to output (can't contain a "!)
|
|
end="\" " # End stuff to output
|
|
subs="@\" " # Substitute start (substitute a C macro)
|
|
sube=" \"@" # Substitute end
|
|
comment=start "/*" # Comment start
|
|
cend="*/" end # Comment end
|
|
def=start "#define PNG_" # Arbitrary define
|
|
sup="_SUPPORTED" end # end supported option
|
|
und=comment "#undef PNG_" # Unsupported option
|
|
une="_SUPPORTED" cend # end unsupported option
|
|
error=start "ERROR:" # error message, terminate with 'end'
|
|
|
|
# Variables
|
|
deb=0 # debug - set on command line
|
|
everything="" # do not override defaults
|
|
logunsupported=0 # write unsupported options too
|
|
|
|
# Precreate arrays
|
|
# for each option:
|
|
option[""] = "" # list of all options: default enabled/disabled
|
|
done[""] = 1 # marks option as having been output
|
|
requires[""] = "" # requires by option
|
|
iffs[""] = "" # if by option
|
|
enabledby[""] = "" # options that enable it by option
|
|
sets[""] = "" # settings set by each option
|
|
setval[""] = "" # value to set (indexed: 'option sets[option]')
|
|
# for each setting:
|
|
setting[""] = "" # requires by setting
|
|
defaults[""] = "" # used for a defaulted value
|
|
doneset[""] = 1 # marks setting as having been output
|
|
r[""] = "" # Temporary array
|
|
|
|
# For decorating the output file
|
|
protect = ""
|
|
}
|
|
|
|
# The output file must be specified before any input:
|
|
out == "" {
|
|
print "out=output.file must be given on the command line"
|
|
err = 1
|
|
exit 1
|
|
}
|
|
|
|
# The very first line indicates whether we are reading pre-processed
|
|
# input or not, this must come *first* because 'PREPROCESSED' needs
|
|
# to be the very first line in the temporary file.
|
|
pre == -1{
|
|
if ($0 == "PREPROCESSED") {
|
|
pre = 0
|
|
next
|
|
} else {
|
|
pre = 1
|
|
print "PREPROCESSED" >out
|
|
# And fall through to continue processing
|
|
}
|
|
}
|
|
|
|
# While pre-processing if version is set to "search" look for a version string
|
|
# in the following file.
|
|
pre && version == "search" && version_file == ""{
|
|
version_file = FILENAME
|
|
}
|
|
|
|
pre && version == "search" && version_file != FILENAME{
|
|
print "version string not found in", version_file
|
|
err = 1
|
|
exit 1
|
|
}
|
|
|
|
pre && version == "search" && $0 ~ /^ \* libpng version/{
|
|
version = substr($0, 4)
|
|
print "version =", version >out
|
|
next
|
|
}
|
|
|
|
pre && FILENAME == version_file{
|
|
next
|
|
}
|
|
|
|
# variable=value
|
|
# Sets the given variable to the given value (the syntax is fairly
|
|
# free form, except for deb (you are expected to understand how to
|
|
# set the debug variable...)
|
|
#
|
|
# This happens before the check on 'pre' below skips most of the
|
|
# rest of the actions, so the variable settings happen during
|
|
# preprocessing but are recorded in the END action too. This
|
|
# allows them to be set on the command line too.
|
|
$0 ~ /^[ ]*version[ ]*=/{
|
|
sub(/^[ ]*version[ ]*=[ ]*/, "")
|
|
version = $0
|
|
next
|
|
}
|
|
$0 ~ /^[ ]*everything[ =]*off[ ]*$/{
|
|
everything = "off"
|
|
next
|
|
}
|
|
$0 ~ /^[ ]*everything[ =]*on[ ]*$/{
|
|
everything = "on"
|
|
next
|
|
}
|
|
$0 ~ /^[ ]*logunsupported[ =]*0[ ]*$/{
|
|
logunsupported = 0
|
|
next
|
|
}
|
|
$0 ~ /^[ ]*logunsupported[ =]*1[ ]*$/{
|
|
logunsupported = 1
|
|
next
|
|
}
|
|
$1 == "deb" && $2 == "=" && NF == 3{
|
|
deb = $3
|
|
next
|
|
}
|
|
|
|
# Preprocessing - this just copies the input file with lines
|
|
# that need preprocessing (just chunk at present) expanded
|
|
# The bare "pre" instead of "pre != 0" crashes under Sunos awk
|
|
pre && $1 != "chunk"{
|
|
print >out
|
|
next
|
|
}
|
|
|
|
# The first characters of the line determine how it is processed,
|
|
# leading spaces are ignored. In general tokens that are not
|
|
# keywords are the names of options. An option 'name' is
|
|
# controlled by the definition of the corresponding macros:
|
|
#
|
|
# PNG_name_SUPPORTED The option is turned on
|
|
# PNG_NO_name
|
|
# PNG_NO_name_SUPPORTED If the first macro is not defined
|
|
# either of these will turn the option off
|
|
#
|
|
# If none of these macros are defined the option is turned on, unless
|
|
# the keyword 'off' is given in a line relating to the option. The
|
|
# keyword 'on' can also be given, but it will be ignored (since it is
|
|
# the default.)
|
|
#
|
|
# In the syntax below a 'name' is indicated by "NAME", other macro
|
|
# values are indicated by "MACRO", as with "NAME" the leading "PNG_"
|
|
# is omitted, but in this case the "NO_" prefix and the "_SUPPORTED"
|
|
# suffix are never used.
|
|
#
|
|
# Each line is introduced by a keyword - the first non-space characters
|
|
# on the line. A line starting with a '#' is a comment - it is totally
|
|
# ignored. Keywords are as follows, a NAME, is simply a macro name
|
|
# without the leading PNG_, PNG_NO_ or the trailing _SUPPORTED.
|
|
|
|
$1 ~ /^#/ || $0 ~ /^[ ]*$/{
|
|
next
|
|
}
|
|
|
|
# com <comment>
|
|
# The whole line is placed in the output file as a comment with
|
|
# the preceding 'com' removed
|
|
$1 == "com"{
|
|
if (NF > 1) {
|
|
# sub(/^[ ]*com[ ]*/, "")
|
|
$1 = ""
|
|
print comment $0, cend >out
|
|
} else
|
|
print start end >out
|
|
next
|
|
}
|
|
|
|
# version
|
|
# Inserts a version comment
|
|
$1 == "version" && NF == 1{
|
|
if (version == "") {
|
|
print "ERROR: no version string set"
|
|
err = 1 # prevent END{} running
|
|
exit 1
|
|
}
|
|
|
|
print comment, version, cend >out
|
|
next
|
|
}
|
|
|
|
# file output input protect
|
|
# Informational: the official name of the input file (without
|
|
# make generated local directories), the official name of the
|
|
# output file and, if required, a name to use in a protection
|
|
# macro for the contents.
|
|
$1 == "file" && NF >= 2{
|
|
print comment, $2, cend >out
|
|
print comment, "Machine generated file: DO NOT EDIT", cend >out
|
|
if (NF >= 3)
|
|
print comment, "Derived from:", $3, cend >out
|
|
protect = $4
|
|
if (protect != "") {
|
|
print start "#ifndef", protect end >out
|
|
print start "#define", protect end >out
|
|
}
|
|
next
|
|
}
|
|
|
|
# option NAME ( (requires|enables|if) NAME* | on | off | disabled |
|
|
# sets SETTING VALUE+ )*
|
|
#
|
|
# Declares an option 'NAME' and describes its default setting (disabled)
|
|
# and its relationship to other options. The option is disabled
|
|
# unless *all* the options listed after 'requires' are set and at
|
|
# least one of the options listed after 'if' is set. If the
|
|
# option is set then it turns on all the options listed after 'enables'.
|
|
#
|
|
# Note that "enables" takes priority over the required/if/disabled/off
|
|
# setting of the target option.
|
|
#
|
|
# The definition file may list an option as 'disabled': off by default,
|
|
# otherwise the option is enabled: on by default. A later (and it must
|
|
# be later) entry may turn an option on or off explicitly.
|
|
|
|
$1 == "option" && NF >= 2{
|
|
opt = $2
|
|
sub(/,$/,"",opt)
|
|
onoff = option[opt] # records current (and the default is "", enabled)
|
|
key = ""
|
|
istart = 3
|
|
do {
|
|
if (istart == 1) { # continuation line
|
|
val = getline
|
|
|
|
if (val != 1) { # error reading it
|
|
if (val == 0)
|
|
print "option", opt ": ERROR: missing contination line"
|
|
else
|
|
print "option", opt ": ERROR: error reading continuation line"
|
|
|
|
# This is a hard error
|
|
err = 1 # prevent END{} running
|
|
exit 1
|
|
}
|
|
}
|
|
|
|
for (i=istart; i<=NF; ++i) {
|
|
val=$(i)
|
|
sub(/,$/,"",val)
|
|
if (val == "on" || val == "off" || val == "disabled") {
|
|
key = ""
|
|
if (onoff != val) {
|
|
# on or off can zap disabled or enabled:
|
|
if (onoff == "" || (onoff == "disabled" || onoff == "enabled") &&
|
|
(val == "on" || val == "off")) {
|
|
# It's easy to mis-spell the option when turning it
|
|
# on or off, so warn about it here:
|
|
if (onoff == "" && (val == "on" || val == "off")) {
|
|
print "option", opt ": ERROR: turning unrecognized option", val
|
|
# For the moment error out - it is safer
|
|
err = 1 # prevent END{} running
|
|
exit 1
|
|
}
|
|
onoff = val
|
|
} else {
|
|
# Print a message, otherwise the error
|
|
# below is incomprehensible
|
|
print "option", opt ": currently", onoff ": attempt to turn", val
|
|
break
|
|
}
|
|
}
|
|
} else if (val == "requires" || val == "if" || val == "enables" || val =="sets") {
|
|
key = val
|
|
} else if (key == "requires") {
|
|
requires[opt] = requires[opt] " " val
|
|
} else if (key == "if") {
|
|
iffs[opt] = iffs[opt] " " val
|
|
} else if (key == "enables") {
|
|
enabledby[val] = enabledby[val] " " opt
|
|
} else if (key == "sets") {
|
|
sets[opt] = sets[opt] " " val
|
|
key = "setval"
|
|
set = val
|
|
} else if (key == "setval") {
|
|
setval[opt " " set] = setval[opt " " set] " " val
|
|
} else
|
|
break # bad line format
|
|
}
|
|
|
|
istart = 1
|
|
} while (i > NF && $0 ~ /,$/)
|
|
|
|
if (i > NF) {
|
|
# Set the option, defaulting to 'enabled'
|
|
if (onoff == "") onoff = "enabled"
|
|
option[opt] = onoff
|
|
next
|
|
}
|
|
# Else fall through to the error handler
|
|
}
|
|
|
|
# chunk NAME [requires OPT] [enables LIST] [on|off|disabled]
|
|
# Expands to the 'option' settings appropriate to the reading and
|
|
# writing of an ancilliary PNG chunk 'NAME':
|
|
#
|
|
# option READ_NAME requires READ_ANCILLARY_CHUNKS [READ_OPT]
|
|
# option READ_NAME enables NAME LIST
|
|
# [option READ_NAME off]
|
|
# option WRITE_NAME requires WRITE_ANCILLARY_CHUNKS [WRITE_OPT]
|
|
# option WRITE_NAME enables NAME LIST
|
|
# [option WRITE_NAME off]
|
|
|
|
pre != 0 && $1 == "chunk" && NF >= 2{
|
|
# 'chunk' is handled on the first pass by writing appropriate
|
|
# 'option' lines into the intermediate file.
|
|
opt = $2
|
|
sub(/,$/,"",opt)
|
|
onoff = ""
|
|
reqread = ""
|
|
reqwrite = ""
|
|
enables = ""
|
|
req = 0
|
|
istart = 3
|
|
do {
|
|
if (istart == 1) { # continuation line
|
|
val = getline
|
|
|
|
if (val != 1) { # error reading it
|
|
if (val == 0)
|
|
print "chunk", opt ": ERROR: missing contination line"
|
|
else
|
|
print "chunk", opt ": ERROR: error reading continuation line"
|
|
|
|
# This is a hard error
|
|
err = 1 # prevent END{} running
|
|
exit 1
|
|
}
|
|
}
|
|
|
|
# read the keywords/additional OPTS
|
|
for (i=istart; i<=NF; ++i) {
|
|
val = $(i)
|
|
sub(/,$/,"",val)
|
|
if (val == "on" || val == "off" || val == "disabled") {
|
|
if (onoff != val) {
|
|
if (onoff == "")
|
|
onoff = val
|
|
else
|
|
break # on/off conflict
|
|
}
|
|
req = 0
|
|
} else if (val == "requires")
|
|
req = 1
|
|
else if (val == "enables")
|
|
req = 2
|
|
else if (req == 1){
|
|
reqread = reqread " READ_" val
|
|
reqwrite = reqwrite " WRITE_" val
|
|
} else if (req == 2)
|
|
enables = enables " " val
|
|
else
|
|
break # bad line: handled below
|
|
}
|
|
|
|
istart = 1
|
|
} while (i > NF && $0 ~ /,$/)
|
|
|
|
if (i > NF) {
|
|
# Output new 'option' lines to the intermediate file (out)
|
|
print "option READ_" opt, "requires READ_ANCILLARY_CHUNKS" reqread, "enables", opt enables , onoff >out
|
|
print "option WRITE_" opt, "requires WRITE_ANCILLARY_CHUNKS" reqwrite, "enables", opt enables, onoff >out
|
|
next
|
|
}
|
|
# Else hit the error handler below - bad line format!
|
|
}
|
|
|
|
# setting MACRO ( requires MACRO* )* [ default VALUE ]
|
|
# Behaves in a similar way to 'option' without looking for NO_ or
|
|
# _SUPPORTED; the macro is enabled if it is defined so long as all
|
|
# the 'requires' macros are also defined. The definitions may be
|
|
# empty, an error will be issued if the 'requires' macros are
|
|
# *not* defined. If given the 'default' value is used if the
|
|
# macro is not defined. The default value will be re-tokenised.
|
|
# (BTW: this is somewhat restrictive, it mainly exists for the
|
|
# support of non-standard configurations and numeric parameters,
|
|
# see the uses in scripts/options.dat
|
|
|
|
$1 == "setting" && (NF == 2 || NF >= 3 && ($3 == "requires" || $3 == "default")){
|
|
reqs = ""
|
|
deflt = ""
|
|
isdef = 0
|
|
key = ""
|
|
for (i=3; i<=NF; ++i)
|
|
if ($(i) == "requires" || $(i) == "default") {
|
|
key = $(i)
|
|
if (key == "default") isdef = 1
|
|
} else if (key == "requires")
|
|
reqs = reqs " " $(i)
|
|
else if (key == "default")
|
|
deflt = deflt " " $(i)
|
|
else
|
|
break # Format error, handled below
|
|
|
|
setting[$2] = reqs
|
|
# NOTE: this overwrites a previous value silently
|
|
if (isdef && deflt == "")
|
|
deflt = " " # as a flag to force output
|
|
defaults[$2] = deflt
|
|
next
|
|
}
|
|
|
|
# The order of the dependency lines (option, chunk, setting) is irrelevant
|
|
# - the 'enables', 'requires' and 'if' settings will be used to determine
|
|
# the correct order in the output and the final values in pnglibconf.h are
|
|
# not order dependent. 'requires' and 'if' entries take precedence over
|
|
# 'enables' from other options; if an option requires another option it
|
|
# won't be set regardless of any options that enable it unless the other
|
|
# option is also enabled.
|
|
#
|
|
# Similarly 'enables' trumps a NO_ definition in CFLAGS or pngusr.h
|
|
#
|
|
# For simplicity cycles in the definitions are regarded as errors,
|
|
# even if they are not ambiguous.
|
|
# A given NAME can be specified in as many 'option' lines as required, the
|
|
# definitions are additive.
|
|
|
|
# For backwards compatibility equivalent macros may be listed thus:
|
|
#
|
|
# = [NO_]NAME MACRO
|
|
# Makes -DMACRO equivalent to -DPNG_NO_NAME or -DPNG_NAME_SUPPORTED
|
|
# as appropriate.
|
|
#
|
|
# The definition is injected into the C compiler input when encountered
|
|
# in the second pass (so all these definitions appear *after* the @
|
|
# lines!)
|
|
#
|
|
# 'NAME' is as above, but 'MACRO' is the full text of the equivalent
|
|
# old, deprecated, macro.
|
|
|
|
$1 == "=" && NF == 3{
|
|
print "#ifdef PNG_" $3 >out
|
|
if ($2 ~ /^NO_/)
|
|
print "# define PNG_" $2 >out
|
|
else
|
|
print "# define PNG_" $2 "_SUPPORTED" >out
|
|
print "#endif" >out
|
|
next
|
|
}
|
|
|
|
# Lines may be injected into the C compiler input by preceding them
|
|
# with an "@" character. The line is copied with just the leading
|
|
# @ removed.
|
|
|
|
$1 ~ /^@/{
|
|
# sub(/^[ ]*@/, "")
|
|
$1 = substr($1, 2)
|
|
print >out
|
|
next
|
|
}
|
|
|
|
# Check for unreognized lines, because of the preprocessing chunk
|
|
# format errors will be detected on the first pass independent of
|
|
# any other format errors.
|
|
{
|
|
print "options.awk: bad line (" NR "):", $0
|
|
err = 1 # prevent END{} running
|
|
exit 1
|
|
}
|
|
|
|
# For checking purposes names that start with "ok_" or "fail_" are
|
|
# not output to pnglibconf.h and must be either enabled or disabled
|
|
# respectively for the build to succeed. This allows interdependencies
|
|
# between options of the form "at least one of" or "at most one of"
|
|
# to be checked. For example:
|
|
#
|
|
# option FLOATING_POINT enables ok_math
|
|
# option FIXED_POINT enables ok_math
|
|
# This ensures that at least one of FLOATING_POINT and FIXED_POINT
|
|
# must be set for the build to succeed.
|
|
#
|
|
# option fail_math requires FLOATING_POINT FIXED_POINT
|
|
# This means the build will fail if *both* FLOATING_POINT and
|
|
# FIXED_POINT are set (this is an example; in fact both are allowed.)
|
|
#
|
|
# If all these options were given the build would require exactly one
|
|
# of the names to be enabled.
|
|
|
|
END{
|
|
# END{} gets run on an exit (a traditional awk feature)
|
|
if (err) exit 1
|
|
|
|
if (pre) {
|
|
# Record the final value of the variables
|
|
print "deb =", deb >out
|
|
if (everything != "") {
|
|
print "everything =", everything >out
|
|
}
|
|
print "logunsupported =", logunsupported >out
|
|
exit 0
|
|
}
|
|
|
|
# Do the options first (allowing options to set settings). The dependency
|
|
# tree is thus:
|
|
#
|
|
# name > name
|
|
# name requires name
|
|
# name if name
|
|
# name enabledby name
|
|
#
|
|
# First build a list 'tree' by option of all the things on which
|
|
# it depends.
|
|
print "" >out
|
|
print "/* OPTIONS */" >out
|
|
print comment, "options", cend >out
|
|
for (opt in enabledby) tree[opt] = 1 # may not be explicit options
|
|
for (opt in option) if (opt != "") {
|
|
o = option[opt]
|
|
# option should always be one of the following values
|
|
if (o != "on" && o != "off" && o != "disabled" && o != "enabled") {
|
|
print "internal option error (" o ")"
|
|
exit 1
|
|
}
|
|
tree[opt] = "" # so unlisted options marked
|
|
}
|
|
for (opt in tree) if (opt != "") {
|
|
if (tree[opt] == 1) {
|
|
tree[opt] = ""
|
|
if (option[opt] != "") {
|
|
print "internal error (1)"
|
|
exit 1
|
|
}
|
|
# Macros only listed in 'enables' remain off unless
|
|
# one of the enabling macros is on.
|
|
option[opt] = "disabled"
|
|
}
|
|
|
|
split("", list) # clear 'list'
|
|
# Now add every requires, iffs or enabledby entry to 'list'
|
|
# so that we can add a unique list of requirements to tree[i]
|
|
split(requires[opt] iffs[opt] enabledby[opt], r)
|
|
for (i in r) list[r[i]] = 1
|
|
for (i in list) tree[opt] = tree[opt] " " i
|
|
}
|
|
|
|
# print the tree for extreme debugging
|
|
if (deb > 2) for (i in tree) if (i != "") print i, "depends-on" tree[i]
|
|
|
|
# Ok, now check all options marked explicitly 'on' or 'off':
|
|
#
|
|
# If an option[opt] is 'on' then turn on all requires[opt]
|
|
# If an option[opt] is 'off' then turn off all enabledby[opt]
|
|
#
|
|
# Error out if we have to turn 'on' an 'off' option or vice versa.
|
|
npending = 0
|
|
for (opt in option) if (opt != "") {
|
|
if (option[opt] == "on" || option[opt] == "off") {
|
|
pending[++npending] = opt
|
|
}
|
|
}
|
|
|
|
err = 0 # set on error
|
|
while (npending > 0) {
|
|
opt = pending[npending--]
|
|
if (option[opt] == "on") {
|
|
nreqs = split(requires[opt], r)
|
|
for (j=1; j<=nreqs; ++j) {
|
|
if (option[r[j]] == "off") {
|
|
print "option", opt, "turned on, but requirement", r[j], "is turned off"
|
|
err = 1
|
|
} else if (option[r[j]] != "on") {
|
|
option[r[j]] = "on"
|
|
pending[++npending] = r[j]
|
|
}
|
|
}
|
|
} else {
|
|
if (option[opt] != "off") {
|
|
print "internal error (2)"
|
|
exit 1
|
|
}
|
|
nreqs = split(enabledby[opt], r)
|
|
for (j=1; j<=nreqs; ++j) {
|
|
if (option[r[j]] == "on") {
|
|
print "option", opt, "turned off, but enabled by", r[j], "which is turned on"
|
|
err = 1
|
|
} else if (option[r[j]] != "off") {
|
|
option[r[j]] = "off"
|
|
pending[++npending] = r[j]
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (err) exit 1
|
|
|
|
# Sort options:
|
|
print "PNG_DFN_START_SORT 2" >out
|
|
|
|
# option[i] is now the complete list of all the tokens we may
|
|
# need to output, go through it as above, depth first.
|
|
finished = 0
|
|
while (!finished) {
|
|
finished = 1
|
|
movement = 0 # done nothing
|
|
for (i in option) if (!done[i]) {
|
|
nreqs = split(tree[i], r)
|
|
if (nreqs > 0) {
|
|
for (j=1; j<=nreqs; ++j) if (!done[r[j]]) {
|
|
break
|
|
}
|
|
if (j<=nreqs) {
|
|
finished = 0
|
|
continue # next option
|
|
}
|
|
}
|
|
|
|
# All the requirements have been processed, output
|
|
# this option. An option is _SUPPORTED if:
|
|
#
|
|
# all 'requires' are _SUPPORTED AND
|
|
# at least one of the 'if' options are _SUPPORTED AND
|
|
# EITHER:
|
|
# The name is _SUPPORTED (on the command line)
|
|
# OR:
|
|
# an 'enabledby' is _SUPPORTED
|
|
# OR:
|
|
# NO_name is not defined AND
|
|
# the option is not disabled; an option is disabled if:
|
|
# option == off
|
|
# option == disabled && everything != on
|
|
# option == "" && everything == off
|
|
if (deb) print "option", i
|
|
print "" >out
|
|
print "/* option:", i, option[i] >out
|
|
print " * requires: " requires[i] >out
|
|
print " * if: " iffs[i] >out
|
|
print " * enabled-by:" enabledby[i] >out
|
|
print " * sets: " sets[i], "*/" >out
|
|
print "#undef PNG_on" >out
|
|
print "#define PNG_on 1" >out
|
|
|
|
# requires
|
|
nreqs = split(requires[i], r)
|
|
for (j=1; j<=nreqs; ++j) {
|
|
print "#ifndef PNG_" r[j] "_SUPPORTED" >out
|
|
print "# undef PNG_on /*!" r[j] "*/" >out
|
|
# this error appears in the final output if something
|
|
# was switched 'on' but the processing above to force
|
|
# the requires did not work
|
|
if (option[i] == "on") {
|
|
print error, i, "requires", r[j] end >out
|
|
}
|
|
print "#endif" >out
|
|
}
|
|
|
|
# if
|
|
nreqs = split(iffs[i], r)
|
|
print "#undef PNG_no_if" >out
|
|
if (nreqs > 0) {
|
|
print "/* if" iffs[i], "*/" >out
|
|
print "#define PNG_no_if 1" >out
|
|
for (j=1; j<=nreqs; ++j) {
|
|
print "#ifdef PNG_" r[j] "_SUPPORTED" >out
|
|
print "# undef PNG_no_if /*" r[j] "*/" >out
|
|
print "#endif" >out
|
|
}
|
|
print "#ifdef PNG_no_if /*missing if*/" >out
|
|
print "# undef PNG_on" >out
|
|
# There is no checking above for this, because we
|
|
# don't know which 'if' to choose, so whine about
|
|
# it here:
|
|
if (option[i] == "on") {
|
|
print error, i, "needs one of:", iffs[i] end >out
|
|
}
|
|
print "#endif" >out
|
|
}
|
|
|
|
print "#ifdef PNG_on /*requires, if*/" >out
|
|
# enables
|
|
print "# undef PNG_not_enabled" >out
|
|
print "# define PNG_not_enabled 1" >out
|
|
print " /* enabled by" enabledby[i], "*/" >out
|
|
nreqs = split(enabledby[i], r)
|
|
for (j=1; j<=nreqs; ++j) {
|
|
print "#ifdef PNG_" r[j] "_SUPPORTED" >out
|
|
print "# undef PNG_not_enabled /*" r[j] "*/" >out
|
|
# Oops, probably not intended (should be factored
|
|
# out by the checks above).
|
|
if (option[i] == "off") {
|
|
print error, i, "enabled by:", r[j] end >out
|
|
}
|
|
print "#endif" >out
|
|
}
|
|
|
|
print "# ifndef PNG_" i "_SUPPORTED /*!command line*/" >out
|
|
print "# ifdef PNG_not_enabled /*!enabled*/" >out
|
|
if (option[i] == "off" || option[i] == "disabled" && everything != "on" || option[i] == "enabled" && everything == "off") {
|
|
print "# undef PNG_on /*default off*/" >out
|
|
} else {
|
|
print "# ifdef PNG_NO_" i >out
|
|
print "# undef PNG_on /*turned off*/" >out
|
|
print "# endif" >out
|
|
print "# ifdef PNG_NO_" i "_SUPPORTED" >out
|
|
print "# undef PNG_on /*turned off*/" >out
|
|
print "# endif" >out
|
|
}
|
|
print "# endif /*!enabled*/" >out
|
|
print "# ifdef PNG_on" >out
|
|
# The _SUPPORTED macro must be defined so that dependent
|
|
# options output later work.
|
|
print "# define PNG_" i "_SUPPORTED" >out
|
|
print "# endif" >out
|
|
print "# endif /*!command line*/" >out
|
|
# If PNG_on is still set the option should be defined in
|
|
# pnglibconf.h
|
|
print "# ifdef PNG_on" >out
|
|
if (i ~ /^fail_/) {
|
|
print error, i, "is on: enabled by:" iffs[i] enabledby[i] ", requires" requires[i] end >out
|
|
} else if (i !~ /^ok_/) {
|
|
print def i sup >out
|
|
# Supported option, set required settings
|
|
nreqs = split(sets[i], r)
|
|
for (j=1; j<=nreqs; ++j) {
|
|
print "# ifdef PNG_set_" r[j] >out
|
|
# Some other option has already set a value:
|
|
print error, i, "sets", r[j] ": duplicate setting" end >out
|
|
print error, " previous value: " end "PNG_set_" r[j] >out
|
|
print "# else" >out
|
|
# Else set the default: note that this won't accept arbitrary
|
|
# values, the setval string must be acceptable to all the C
|
|
# compilers we use. That means it must be VERY simple; a number,
|
|
# a name or a string.
|
|
print "# define PNG_set_" r[j], setval[i " " r[j]] >out
|
|
print "# endif" >out
|
|
}
|
|
}
|
|
print "# endif /* definition */" >out
|
|
print "#endif /*requires, if*/" >out
|
|
if (logunsupported || i ~ /^ok_/) {
|
|
print "#ifndef PNG_on" >out
|
|
if (logunsupported) {
|
|
print und i une >out
|
|
}
|
|
if (i ~ /^ok_/) {
|
|
print error, i, "not enabled: requires:" requires[i] ", enabled by:" iffs[i] enabledby[i] end >out
|
|
}
|
|
print "#endif" >out
|
|
}
|
|
|
|
done[i] = 1
|
|
++movement
|
|
}
|
|
|
|
if (!finished && !movement) {
|
|
print "option: loop or missing option in dependency tree, cannot process:"
|
|
for (i in option) if (!done[i]) {
|
|
print " option", i, "depends on" tree[i], "needs:"
|
|
nreqs = split(tree[i], r)
|
|
if (nreqs > 0) for (j=1; j<=nreqs; ++j) if (!done[r[j]]) {
|
|
print " " r[j]
|
|
}
|
|
}
|
|
exit 1
|
|
}
|
|
}
|
|
print "PNG_DFN_END_SORT" >out
|
|
print comment, "end of options", cend >out
|
|
|
|
# Do the 'setting' values second, the algorithm the standard
|
|
# tree walk (O(1)) done in an O(2) while/for loop; interations
|
|
# settings x depth, outputing the deepest required macros
|
|
# first.
|
|
print "" >out
|
|
print "/* SETTINGS */" >out
|
|
print comment, "settings", cend >out
|
|
# Sort (in dfn.awk) on field 2, the setting name
|
|
print "PNG_DFN_START_SORT 2" >out
|
|
finished = 0
|
|
while (!finished) {
|
|
finished = 1
|
|
movement = 0 # done nothing
|
|
for (i in setting) if (!doneset[i]) {
|
|
nreqs = split(setting[i], r)
|
|
if (nreqs > 0) {
|
|
# By default assume the requires values are options, but if there
|
|
# is no option with that name check for a setting
|
|
for (j=1; j<=nreqs; ++j) if (option[r[j]] == "" && !doneset[r[j]]) {
|
|
break
|
|
}
|
|
if (j<=nreqs) {
|
|
finished = 0
|
|
continue # try a different setting
|
|
}
|
|
}
|
|
|
|
# All the requirements have been processed, output
|
|
# this setting.
|
|
if (deb) print "setting", i
|
|
deflt = defaults[i]
|
|
# Remove any spurious trailing spaces
|
|
sub(/ *$/,"",deflt)
|
|
# A leading @ means leave it unquoted so the preprocessor
|
|
# can substitute the build time value
|
|
if (deflt ~ /^ @/)
|
|
deflt = " " subs substr(deflt, 3) sube
|
|
print "" >out
|
|
print "/* setting: ", i >out
|
|
print " * requires:" setting[i] >out
|
|
print " * default: ", defaults[i] deflt, "*/" >out
|
|
for (j=1; j<=nreqs; ++j) {
|
|
if (option[r[j]] != "")
|
|
print "#ifndef PNG_" r[j] "_SUPPORTED" >out
|
|
else
|
|
print "#ifndef PNG_" r[j] >out
|
|
print error, i, "requires", r[j] end >out
|
|
print "# endif" >out
|
|
}
|
|
# The precedence is:
|
|
#
|
|
# 1) External definition; trumps:
|
|
# 2) Option 'sets' value; trumps:
|
|
# 3) Setting 'default'
|
|
#
|
|
print "#ifdef PNG_" i >out
|
|
# PNG_<i> is defined, so substitute the value:
|
|
print def i, subs "PNG_" i sube end >out
|
|
print "#else /* use default */" >out
|
|
print "# ifdef PNG_set_" i >out
|
|
# Value from an option 'sets' argument
|
|
print def i, subs "PNG_set_" i sube end >out
|
|
# This is so that subsequent tests on the setting work:
|
|
print "# define PNG_" i, "1" >out
|
|
if (defaults[i] != "") {
|
|
print "# else /*default*/" >out
|
|
print def i deflt end >out
|
|
print "# define PNG_" i, "1" >out
|
|
}
|
|
print "# endif /* defaults */" >out
|
|
print "#endif /* setting", i, "*/" >out
|
|
|
|
doneset[i] = 1
|
|
++movement
|
|
}
|
|
|
|
if (!finished && !movement) {
|
|
print "setting: loop or missing setting in 'requires', cannot process:"
|
|
for (i in setting) if (!doneset[i]) {
|
|
print " setting", i, "requires" setting[i]
|
|
}
|
|
exit 1
|
|
}
|
|
}
|
|
print "PNG_DFN_END_SORT" >out
|
|
print comment, "end of settings", cend >out
|
|
|
|
# Regular end - everything looks ok
|
|
if (protect != "") {
|
|
print start "#endif", "/*", protect, "*/" end >out
|
|
}
|
|
}
|