| #!/bin/awk -f | |
| # scripts/options.awk - library build configuration control | |
| # | |
| # Copyright (c) 1998-2014 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), preceded 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 continuation 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" || val =="enabled") { | |
| 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 ancillary 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 continuation 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 unrecognized 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' to 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 | |
| have_ifs = 0 | |
| nreqs = split(iffs[i], r) | |
| print "#undef PNG_no_if" >out | |
| if (nreqs > 0) { | |
| have_ifs = 1 | |
| 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 | |
| # 'have_ifs' here means that everything = "off" still allows an 'if' on | |
| # an otherwise enabled option to turn it on; otherwise the 'if' | |
| # handling is effectively disabled by 'everything = off' | |
| if ((option[i] == "off") || | |
| (option[i] == "disabled" && everything != "on") || | |
| (option[i] == "enabled" && everything == "off" && !have_ifs)) { | |
| 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; iterations | |
| # settings x depth, outputting 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 | |
| } | |
| } |