[BACK]Return to vardefs.go CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / pkgsrc / pkgtools / pkglint / files

Annotation of pkgsrc/pkgtools/pkglint/files/vardefs.go, Revision 1.73

1.52      rillig      1: package pkglint
1.1       rillig      2:
1.4       rillig      3: import (
1.49      rillig      4:        "netbsd.org/pkglint/regex"
1.4       rillig      5:        "path"
                      6:        "strings"
                      7: )
                      8:
1.57      rillig      9: // This file defines the type and the access permissions of most pkgsrc
                     10: // variables.
1.1       rillig     11: //
1.57      rillig     12: // Some types are plain values, some are lists. Lists are split like in the
                     13: // shell, using "double" and 'single' quotes to enclose spaces.
1.1       rillig     14: //
                     15: // See vartypecheck.go for how these types are checked.
1.57      rillig     16: //
                     17: // The permissions depend on the name of the file where the variable is
                     18: // either assigned or used. There are several types of Makefile fragments
                     19: // in pkgsrc, and some of them have very specific tasks, like buildlink3.mk,
                     20: // builtin.mk and options.mk.
                     21: //
                     22: // TODO: There are separate permission rules for files from the pkgsrc
                     23: //  infrastructure since the infrastructure basically provides the API, and
                     24: //  the packages use the API.
                     25: //
                     26: // Variables that are defined by packages are usually used by the
                     27: // infrastructure, and vice versa. There are also user-defined variables,
                     28: // which from the view point of a package, are the same as variables
                     29: // defined by the infrastructure.
                     30:
                     31: type VarTypeRegistry struct {
                     32:        types map[string]*Vartype // varcanon => type
                     33: }
                     34:
                     35: func NewVarTypeRegistry() VarTypeRegistry {
                     36:        return VarTypeRegistry{make(map[string]*Vartype)}
                     37: }
                     38:
                     39: func (reg *VarTypeRegistry) Canon(varname string) *Vartype {
                     40:        vartype := reg.types[varname]
                     41:        if vartype == nil {
                     42:                vartype = reg.types[varnameCanon(varname)]
                     43:        }
                     44:        return vartype
                     45: }
                     46:
                     47: func (reg *VarTypeRegistry) DefinedExact(varname string) bool {
                     48:        return reg.types[varname] != nil
                     49: }
                     50:
                     51: func (reg *VarTypeRegistry) DefinedCanon(varname string) bool {
                     52:        return reg.Canon(varname) != nil
                     53: }
                     54:
                     55: func (reg *VarTypeRegistry) DefineType(varcanon string, vartype *Vartype) {
                     56:        reg.types[varcanon] = vartype
                     57: }
                     58:
1.59      rillig     59: func (reg *VarTypeRegistry) Define(varname string, basicType *BasicType, options vartypeOptions, aclEntries ...ACLEntry) {
1.57      rillig     60:        m, varbase, varparam := match2(varname, `^([A-Z_.][A-Z0-9_]*|@)(|\*|\.\*)$`)
1.68      rillig     61:        assert(m) // invalid variable name
1.57      rillig     62:
1.66      rillig     63:        vartype := NewVartype(basicType, options, aclEntries...)
1.57      rillig     64:
                     65:        if varparam == "" || varparam == "*" {
1.66      rillig     66:                reg.types[varbase] = vartype
1.57      rillig     67:        }
                     68:        if varparam == "*" || varparam == ".*" {
1.66      rillig     69:                reg.types[varbase+".*"] = vartype
1.57      rillig     70:        }
                     71: }
                     72:
                     73: // DefineParse defines a variable with the given type and permissions.
                     74: //
                     75: // A permission entry looks like this:
                     76: //  "Makefile, Makefile.*, *.mk: default, set, append, use, use-loadtime"
                     77: // Only certain filenames are allowed in the part before the colon,
                     78: // to prevent typos. To use arbitrary filenames, prefix them with
                     79: // "special:".
                     80: //
                     81: // TODO: To be implemented: when prefixed with "infra:", the entry only
                     82: //  applies to files within the pkgsrc infrastructure. Without this prefix,
                     83: //  the pattern only applies to files outside the pkgsrc infrastructure.
1.59      rillig     84: func (reg *VarTypeRegistry) DefineParse(varname string, basicType *BasicType, options vartypeOptions, aclEntries ...string) {
1.57      rillig     85:        parsedEntries := reg.parseACLEntries(varname, aclEntries...)
1.59      rillig     86:        reg.Define(varname, basicType, options, parsedEntries...)
1.57      rillig     87: }
1.1       rillig     88:
1.67      rillig     89: // acl defines the permissions of a variable by listing the permissions
                     90: // individually.
                     91: //
                     92: // Each variable that uses this function directly must document:
                     93: //  - which of the predefined permission sets is the closest
                     94: //  - how this individual permission set differs
                     95: //  - why the predefined permission set is not good enough
                     96: //  - which packages need this custom permission set.
                     97: func (reg *VarTypeRegistry) acl(varname string, basicType *BasicType, options vartypeOptions, aclEntries ...string) {
                     98:        assertf(!reg.DefinedExact(varname), "Variable %q must only be defined once.", varname)
                     99:        reg.DefineParse(varname, basicType, options, aclEntries...)
                    100: }
                    101:
                    102: // acllist defines the permissions of a list variable by listing
                    103: // the permissions individually.
                    104: //
                    105: // Each variable that uses this function directly must document:
                    106: //  - which of the predefined permission sets is the closest
                    107: //  - how this individual permission set differs
                    108: //  - why the predefined permission set is not good enough
                    109: //  - which packages need this custom permission set.
                    110: func (reg *VarTypeRegistry) acllist(varname string, basicType *BasicType, options vartypeOptions, aclEntries ...string) {
                    111:        reg.acl(varname, basicType, options|List, aclEntries...)
                    112: }
1.38      rillig    113:
1.67      rillig    114: // A package-settable variable may be set in all Makefiles except buildlink3.mk and builtin.mk.
                    115: func (reg *VarTypeRegistry) pkg(varname string, basicType *BasicType) {
                    116:        reg.acl(varname, basicType,
                    117:                PackageSettable,
                    118:                "buildlink3.mk, builtin.mk: none",
                    119:                "Makefile, Makefile.*, *.mk: default, set, use")
                    120: }
1.38      rillig    121:
1.67      rillig    122: // Like pkg, but always needs a rationale.
                    123: func (reg *VarTypeRegistry) pkgrat(varname string, basicType *BasicType) {
                    124:        reg.acl(varname, basicType,
                    125:                PackageSettable|NeedsRationale,
                    126:                "buildlink3.mk, builtin.mk: none",
                    127:                "Makefile, Makefile.*, *.mk: default, set, use")
                    128: }
1.38      rillig    129:
1.67      rillig    130: // pkgload is the same as pkg, except that the variable may be accessed at load time.
                    131: func (reg *VarTypeRegistry) pkgload(varname string, basicType *BasicType) {
                    132:        reg.acl(varname, basicType,
                    133:                PackageSettable,
                    134:                "buildlink3.mk: none",
                    135:                "builtin.mk: use, use-loadtime",
                    136:                "Makefile, Makefile.*, *.mk: default, set, use, use-loadtime")
                    137: }
1.57      rillig    138:
1.67      rillig    139: // A package-defined list may be defined and appended to in all Makefiles
                    140: // except buildlink3.mk and builtin.mk. Simple assignment (instead of
                    141: // appending) is also allowed. If this leads of an unconditional
                    142: // assignment overriding a previous value, the redundancy check will
                    143: // catch it.
                    144: func (reg *VarTypeRegistry) pkglist(varname string, basicType *BasicType) {
                    145:        reg.acllist(varname, basicType,
                    146:                List|PackageSettable,
                    147:                "buildlink3.mk, builtin.mk: none",
                    148:                "Makefile, Makefile.*, *.mk: default, set, append, use")
                    149: }
1.62      rillig    150:
1.67      rillig    151: // Like pkglist, but always needs a rationale.
                    152: func (reg *VarTypeRegistry) pkglistrat(varname string, basicType *BasicType) {
                    153:        reg.acllist(varname, basicType,
                    154:                List|PackageSettable|NeedsRationale,
                    155:                "buildlink3.mk, builtin.mk: none",
                    156:                "Makefile, Makefile.*, *.mk: default, set, append, use")
                    157: }
1.16      rillig    158:
1.67      rillig    159: // pkgappend declares a variable that may use the += operator,
                    160: // even though it is not a list where each item can be interpreted
                    161: // on its own.
                    162: //
                    163: // This applies to lists in which a single logical list item is
                    164: // composed of several syntactical words, such as CONF_FILES, which is
                    165: // a list of filename pairs.
                    166: //
                    167: // This also applies to COMMENT, which is not a list at all but a string
                    168: // that is sometimes composed of a common prefix and a package-specific
                    169: // suffix.
                    170: func (reg *VarTypeRegistry) pkgappend(varname string, basicType *BasicType) {
                    171:        reg.acl(varname, basicType,
                    172:                PackageSettable,
                    173:                "buildlink3.mk, builtin.mk: none",
                    174:                "Makefile, Makefile.*, *.mk: default, set, append, use")
                    175: }
1.16      rillig    176:
1.67      rillig    177: func (reg *VarTypeRegistry) pkgappendbl3(varname string, basicType *BasicType) {
                    178:        reg.acl(varname, basicType,
                    179:                PackageSettable,
                    180:                "Makefile, Makefile.*, *.mk: default, set, append, use")
                    181: }
1.62      rillig    182:
1.67      rillig    183: // Some package-defined variables may be modified in buildlink3.mk files.
                    184: // These variables are typically related to compiling and linking files
                    185: // from C and related languages.
                    186: func (reg *VarTypeRegistry) pkgbl3(varname string, basicType *BasicType) {
                    187:        reg.acl(varname, basicType,
                    188:                PackageSettable,
                    189:                "Makefile, Makefile.*, *.mk: default, set, use")
                    190: }
1.62      rillig    191:
1.67      rillig    192: // Some package-defined lists may also be modified in buildlink3.mk files,
                    193: // for example platform-specific CFLAGS and LDFLAGS.
                    194: func (reg *VarTypeRegistry) pkglistbl3(varname string, basicType *BasicType) {
                    195:        reg.acl(varname, basicType,
                    196:                List|PackageSettable,
                    197:                "Makefile, Makefile.*, *.mk: default, set, append, use")
                    198: }
1.56      rillig    199:
1.67      rillig    200: // Like pkglistbl3, but always needs a rationale.
                    201: func (reg *VarTypeRegistry) pkglistbl3rat(varname string, basicType *BasicType) {
                    202:        reg.acl(varname, basicType,
                    203:                List|PackageSettable|NeedsRationale,
                    204:                "Makefile, Makefile.*, *.mk: default, set, append, use")
                    205: }
1.62      rillig    206:
1.67      rillig    207: // sys declares a user-defined or system-defined variable that must not
                    208: // be modified by packages.
                    209: //
                    210: // It also must not be used in buildlink3.mk and builtin.mk files or at
                    211: // load time since the system/user preferences may not have been loaded
                    212: // when these files are included.
                    213: //
                    214: // TODO: These timing issues should be handled separately from the permissions.
                    215: //  They can be made more precise.
                    216: func (reg *VarTypeRegistry) sys(varname string, basicType *BasicType) {
                    217:        reg.acl(varname, basicType,
                    218:                SystemProvided,
                    219:                "buildlink3.mk: none",
                    220:                "*: use")
                    221: }
1.57      rillig    222:
1.67      rillig    223: func (reg *VarTypeRegistry) sysbl3(varname string, basicType *BasicType) {
                    224:        reg.acl(varname, basicType,
                    225:                SystemProvided,
                    226:                "*: use")
                    227: }
1.57      rillig    228:
1.67      rillig    229: func (reg *VarTypeRegistry) syslist(varname string, basicType *BasicType) {
                    230:        reg.acllist(varname, basicType,
                    231:                List|SystemProvided,
                    232:                "buildlink3.mk: none",
                    233:                "*: use")
                    234: }
1.47      rillig    235:
1.67      rillig    236: // usr declares a user-defined variable that must not be modified by packages.
                    237: func (reg *VarTypeRegistry) usr(varname string, basicType *BasicType) {
                    238:        reg.acl(varname, basicType,
                    239:                // TODO: why is builtin.mk missing here?
                    240:                UserSettable,
                    241:                "buildlink3.mk: none",
                    242:                "*: use, use-loadtime")
                    243: }
1.57      rillig    244:
1.67      rillig    245: // usr declares a user-defined list variable that must not be modified by packages.
                    246: func (reg *VarTypeRegistry) usrlist(varname string, basicType *BasicType) {
                    247:        reg.acllist(varname, basicType,
                    248:                // TODO: why is builtin.mk missing here?
                    249:                List|UserSettable,
                    250:                "buildlink3.mk: none",
                    251:                "*: use, use-loadtime")
                    252: }
1.47      rillig    253:
1.67      rillig    254: // A few variables from mk/defaults/mk.conf may be overridden by packages.
                    255: // Therefore they need a separate definition of "user-settable".
                    256: //
                    257: // It is debatable whether packages should be allowed to override these
                    258: // variables at all since then there are two competing sources for the
                    259: // default values. Current practice is to have exactly this ambiguity,
                    260: // combined with some package Makefiles including bsd.prefs.mk and others
                    261: // omitting this necessary inclusion.
                    262: //
                    263: // TODO: parse all the below information directly from mk/defaults/mk.conf.
                    264: func (reg *VarTypeRegistry) usrpkg(varname string, basicType *BasicType) {
                    265:        reg.acl(varname, basicType,
                    266:                PackageSettable|UserSettable,
                    267:                "Makefile: default, set, use, use-loadtime",
                    268:                "buildlink3.mk, builtin.mk: none",
                    269:                "Makefile.*, *.mk: default, set, use, use-loadtime",
                    270:                "*: use, use-loadtime")
                    271: }
1.61      rillig    272:
1.67      rillig    273: // sysload declares a system-provided variable that may already be used at load time.
                    274: func (reg *VarTypeRegistry) sysload(varname string, basicType *BasicType) {
                    275:        reg.acl(varname, basicType,
                    276:                SystemProvided,
                    277:                "*: use, use-loadtime")
                    278: }
1.57      rillig    279:
1.67      rillig    280: func (reg *VarTypeRegistry) sysloadlist(varname string, basicType *BasicType) {
                    281:        reg.acl(varname, basicType,
                    282:                List|SystemProvided,
                    283:                "*: use, use-loadtime")
                    284: }
1.57      rillig    285:
1.67      rillig    286: // bl3list declares a list variable that is defined by buildlink3.mk and
                    287: // builtin.mk and can later be used by the package.
                    288: func (reg *VarTypeRegistry) bl3list(varname string, basicType *BasicType) {
                    289:        reg.acl(varname, basicType,
                    290:                List, // not PackageSettable since the package uses it more than setting it.
                    291:                "buildlink3.mk, builtin.mk: append",
                    292:                "*: use")
                    293: }
1.47      rillig    294:
1.67      rillig    295: // cmdline declares a variable that is defined on the command line. There
                    296: // are only few variables of this type, such as PKG_DEBUG_LEVEL.
                    297: func (reg *VarTypeRegistry) cmdline(varname string, basicType *BasicType) {
                    298:        reg.acl(varname, basicType,
                    299:                CommandLineProvided,
                    300:                "buildlink3.mk, builtin.mk: none",
                    301:                "*: use, use-loadtime")
                    302: }
1.54      rillig    303:
1.67      rillig    304: // Only for infrastructure files; see mk/misc/show.mk
                    305: func (reg *VarTypeRegistry) infralist(varname string, basicType *BasicType) {
                    306:        reg.acllist(varname, basicType,
                    307:                List,
1.72      rillig    308:                "*: set, append, use")
1.67      rillig    309: }
1.16      rillig    310:
1.67      rillig    311: // compilerLanguages reads the available languages that are typically
                    312: // bundled in a single compiler framework, such as GCC or Clang.
                    313: func (reg *VarTypeRegistry) compilerLanguages(src *Pkgsrc) *BasicType {
1.71      rillig    314:        mklines := src.LoadMkInfra("mk/compiler.mk", NotEmpty|MustSucceed)
1.70      rillig    315:
1.67      rillig    316:        languages := make(map[string]bool)
                    317:        if mklines != nil {
                    318:                for _, mkline := range mklines.mklines {
1.69      rillig    319:                        if mkline.IsVarassign() && mkline.Varname() == "_CXX_STD_VERSIONS" {
                    320:                                words := mkline.ValueFields(mkline.Value())
                    321:                                for _, word := range words {
                    322:                                        languages[intern(word)] = true
1.41      rillig    323:                                }
                    324:                        }
1.70      rillig    325:
                    326:                        if mkline.IsDirective() && mkline.Cond() != nil {
                    327:                                mkline.Cond().Walk(&MkCondCallback{
                    328:                                        VarUse: func(varuse *MkVarUse) {
                    329:                                                if varuse.varname == "USE_LANGUAGES" && len(varuse.modifiers) == 1 {
                    330:                                                        ok, _, pattern, exact := varuse.modifiers[0].MatchMatch()
                    331:                                                        if ok && exact && !containsVarRef(pattern) {
                    332:                                                                languages[intern(pattern)] = true
                    333:                                                        }
                    334:                                                }
                    335:                                        }})
                    336:                        }
1.67      rillig    337:                }
                    338:        }
1.69      rillig    339:
1.67      rillig    340:        joined := keysJoined(languages)
                    341:        if trace.Tracing {
                    342:                trace.Stepf("Languages from mk/compiler.mk: %s", joined)
                    343:        }
                    344:
                    345:        return enum(joined)
                    346: }
1.41      rillig    347:
1.67      rillig    348: // enumFrom parses all variable definitions for the given file,
                    349: // and for all variables matching one of the varcanons, all values
                    350: // are added as allowed values.
                    351: //
                    352: // If the file cannot be found, the allowed values are taken from
                    353: // defval. This is mostly useful when testing pkglint.
                    354: func (reg *VarTypeRegistry) enumFrom(pkgsrc *Pkgsrc, filename string, defval string, varcanons ...string) *BasicType {
                    355:        mklines := LoadMk(pkgsrc.File(filename), NotEmpty)
                    356:        if mklines == nil {
                    357:                return enum(defval)
                    358:        }
1.21      rillig    359:
1.67      rillig    360:        values := make(map[string]bool)
                    361:        for _, mkline := range mklines.mklines {
                    362:                if !mkline.IsVarassign() {
                    363:                        continue
1.57      rillig    364:                }
                    365:
1.67      rillig    366:                varcanon := mkline.Varcanon()
                    367:                for _, vc := range varcanons {
                    368:                        if vc != varcanon {
1.57      rillig    369:                                continue
                    370:                        }
1.44      rillig    371:
1.67      rillig    372:                        words := mkline.ValueFields(mkline.Value())
                    373:                        for _, word := range words {
                    374:                                if !contains(word, "$") {
                    375:                                        values[intern(word)] = true
1.44      rillig    376:                                }
                    377:                        }
                    378:                }
1.67      rillig    379:        }
1.44      rillig    380:
1.67      rillig    381:        if len(values) > 0 {
                    382:                joined := keysJoined(values)
                    383:                if trace.Tracing {
                    384:                        trace.Stepf("Enum from %s in %s with values: %s",
                    385:                                strings.Join(varcanons, " "), filename, joined)
1.44      rillig    386:                }
1.67      rillig    387:                return enum(joined)
                    388:        }
                    389:
                    390:        if trace.Tracing {
                    391:                trace.Stepf("Enum from default value: %s", defval)
                    392:        }
                    393:        return enum(defval)
                    394: }
1.44      rillig    395:
1.67      rillig    396: // enumFromDirs reads the package directories from category, takes all
                    397: // that have a single number in them (such as php72) and ranks them
                    398: // from earliest to latest.
                    399: //
                    400: // If the directories cannot be found, the allowed values are taken
                    401: // from defval. This is mostly useful when testing pkglint.
                    402: func (reg *VarTypeRegistry) enumFromDirs(pkgsrc *Pkgsrc, category string, re regex.Pattern, repl string, defval string) *BasicType {
                    403:        versions := pkgsrc.ListVersions(category, re, repl, false)
                    404:        if len(versions) == 0 {
1.43      rillig    405:                return enum(defval)
                    406:        }
1.67      rillig    407:        return enum(strings.Join(versions, " "))
                    408: }
1.43      rillig    409:
1.67      rillig    410: // enumFromFiles reads the files from the given base directory,
                    411: // filtering it through the regular expression and the replacement.
                    412: //
                    413: // If no files are found, the allowed values are taken
                    414: // from defval. This should only happen in the pkglint tests.
                    415: func (reg *VarTypeRegistry) enumFromFiles(basedir string, re regex.Pattern, repl string, defval string) *BasicType {
                    416:        var relevant []string
                    417:        for _, filename := range dirglob(G.Pkgsrc.File(basedir)) {
                    418:                basename := path.Base(filename)
                    419:                if matches(basename, re) {
                    420:                        relevant = append(relevant, replaceAll(basename, re, repl))
1.49      rillig    421:                }
                    422:        }
1.67      rillig    423:        if len(relevant) == 0 {
                    424:                return enum(defval)
                    425:        }
                    426:        return enum(strings.Join(relevant, " "))
                    427: }
1.49      rillig    428:
1.67      rillig    429: // Init initializes the long list of predefined pkgsrc variables.
                    430: // After this is done, PKGNAME, MAKE_ENV and all the other variables
                    431: // can be used in Makefiles without triggering warnings about typos.
                    432: func (reg *VarTypeRegistry) Init(src *Pkgsrc) {
1.59      rillig    433:
1.67      rillig    434:        compilers := reg.enumFrom(src,
1.44      rillig    435:                "mk/compiler.mk",
                    436:                "ccache ccc clang distcc f2c gcc hp icc ido mipspro mipspro-ucode pcc sunpro xlc",
                    437:                "_COMPILERS",
                    438:                "_PSEUDO_COMPILERS")
                    439:
1.67      rillig    440:        emacsVersions := reg.enumFrom(src,
1.44      rillig    441:                "editors/emacs/modules.mk",
                    442:                "emacs25 emacs21 emacs21nox emacs20 xemacs215 xemacs215nox xemacs214 xemacs214nox",
                    443:                "_EMACS_VERSIONS_ALL")
                    444:
1.67      rillig    445:        mysqlVersions := reg.enumFrom(src,
1.44      rillig    446:                "mk/mysql.buildlink3.mk",
                    447:                "57 56 55 51 MARIADB55",
                    448:                "MYSQL_VERSIONS_ACCEPTED")
                    449:
1.67      rillig    450:        pgsqlVersions := reg.enumFrom(src,
1.44      rillig    451:                "mk/pgsql.buildlink3.mk",
                    452:                "10 96 95 94 93",
                    453:                "PGSQL_VERSIONS_ACCEPTED")
                    454:
1.67      rillig    455:        jvms := reg.enumFrom(src,
1.44      rillig    456:                "mk/java-vm.mk",
1.63      wiz       457:                "openjdk8 oracle-jdk8 openjdk7 sun-jdk7 jdk16 jdk15 kaffe",
1.44      rillig    458:                "_PKG_JVMS.*")
                    459:
1.57      rillig    460:        // Last synced with mk/defaults/mk.conf revision 1.300 (fe3d998769f).
1.67      rillig    461:        reg.usr("USE_CWRAPPERS", enum("yes no auto"))
                    462:        reg.usr("ALLOW_VULNERABLE_PACKAGES", BtYes)
                    463:        reg.usrlist("AUDIT_PACKAGES_FLAGS", BtShellWord)
                    464:        reg.usrlist("MANINSTALL", enum("maninstall catinstall"))
                    465:        reg.usr("MANZ", BtYes)
                    466:        reg.usrlist("GZIP", BtShellWord)
                    467:        reg.usr("MAKE_JOBS", BtInteger)
                    468:        reg.usr("OBJHOSTNAME", BtYes)
                    469:        reg.usr("OBJMACHINE", BtYes)
                    470:        reg.usr("SIGN_PACKAGES", enum("gpg x509"))
                    471:        reg.usr("X509_KEY", BtPathname)
                    472:        reg.usr("X509_CERTIFICATE", BtPathname)
                    473:        reg.usr("PATCH_DEBUG", BtYes)
                    474:        reg.usr("PKG_COMPRESSION", enum("gzip bzip2 xz none"))
                    475:        reg.usr("PKGSRC_LOCKTYPE", enum("none sleep once"))
                    476:        reg.usr("PKGSRC_SLEEPSECS", BtInteger)
                    477:        reg.usr("ABI", enum("32 64"))
                    478:        reg.usr("PKG_DEVELOPER", BtYesNo)
                    479:        reg.usr("USE_ABI_DEPENDS", BtYesNo)
                    480:        reg.usr("PKG_REGISTER_SHELLS", enum("YES NO"))
                    481:        reg.usrlist("PKGSRC_COMPILER", compilers)
                    482:        reg.usr("PKGSRC_KEEP_BIN_PKGS", BtYesNo)
                    483:        reg.usrlist("PKGSRC_MESSAGE_RECIPIENTS", BtMailAddress)
                    484:        reg.usr("PKGSRC_SHOW_BUILD_DEFS", BtYesNo)
                    485:        reg.usr("PKGSRC_RUN_TEST", BtYesNo)
                    486:        reg.usr("PKGSRC_MKPIE", BtYesNo)
                    487:        reg.usr("PKGSRC_MKREPRO", BtYesNo)
                    488:        reg.usr("PKGSRC_USE_CTF", BtYesNo)
                    489:        reg.usr("PKGSRC_USE_FORTIFY", enum("no weak strong"))
                    490:        reg.usr("PKGSRC_USE_RELRO", enum("no partial full"))
                    491:        reg.usr("PKGSRC_USE_SSP", enum("no yes strong all"))
                    492:        reg.usr("PKGSRC_USE_STACK_CHECK", enum("no yes"))
                    493:        reg.usr("PREFER.*", enum("pkgsrc native"))
                    494:        reg.usrlist("PREFER_PKGSRC", BtIdentifier)
                    495:        reg.usrlist("PREFER_NATIVE", BtIdentifier)
                    496:        reg.usr("PREFER_NATIVE_PTHREADS", BtYesNo)
                    497:        reg.usr("WRKOBJDIR", BtPathname)
                    498:        reg.usr("LOCALBASE", BtPathname)
                    499:        reg.usr("CROSSBASE", BtPathname)
                    500:        reg.usr("VARBASE", BtPathname)
1.57      rillig    501:
                    502:        // X11_TYPE and X11BASE may be used in buildlink3.mk as well, which the
                    503:        // standard sysload doesn't allow.
1.67      rillig    504:        reg.acl("X11_TYPE", enum("modular native"),
1.59      rillig    505:                UserSettable,
1.57      rillig    506:                "*: use, use-loadtime")
1.67      rillig    507:        reg.acl("X11BASE", BtPathname,
1.59      rillig    508:                UserSettable,
1.57      rillig    509:                "*: use, use-loadtime")
                    510:
1.67      rillig    511:        reg.usr("MOTIFBASE", BtPathname)
                    512:        reg.usr("PKGINFODIR", BtPathname)
1.73    ! rillig    513:        reg.usr("PKGMANDIR", BtPrefixPathname)
1.67      rillig    514:        reg.usr("PKGGNUDIR", BtPathname)
                    515:        reg.usr("BSDSRCDIR", BtPathname)
                    516:        reg.usr("BSDXSRCDIR", BtPathname)
                    517:        reg.usr("DISTDIR", BtPathname)
                    518:        reg.usr("DIST_PATH", BtPathlist)
                    519:        reg.usr("DEFAULT_VIEW", BtUnknown) // XXX: deprecate? pkgviews has been removed
                    520:        reg.usr("FETCH_CMD", BtShellCommand)
                    521:        reg.usr("FIX_SYSTEM_HEADERS", BtYes)
                    522:        reg.usr("LIBTOOLIZE_PLIST", BtYesNo)
                    523:        reg.usr("PKG_RESUME_TRANSFERS", BtYesNo)
                    524:        reg.usr("PKG_SYSCONFBASE", BtPathname)
                    525:        reg.usr("INIT_SYSTEM", enum("rc.d smf"))
                    526:        reg.usr("RCD_SCRIPTS_DIR", BtPathname)
                    527:        reg.usr("PACKAGES", BtPathname)
                    528:        reg.usr("PASSIVE_FETCH", BtYes)
                    529:        reg.usr("PATCH_FUZZ_FACTOR", enum("none -F0 -F1 -F2 -F3"))
                    530:        reg.usrlist("ACCEPTABLE_LICENSES", BtIdentifier)
                    531:        reg.usr("SPECIFIC_PKGS", BtYes)
1.73    ! rillig    532:        reg.usrlist("SITE_SPECIFIC_PKGS", BtPkgpath)
        !           533:        reg.usrlist("HOST_SPECIFIC_PKGS", BtPkgpath)
        !           534:        reg.usrlist("GROUP_SPECIFIC_PKGS", BtPkgpath)
        !           535:        reg.usrlist("USER_SPECIFIC_PKGS", BtPkgpath)
1.67      rillig    536:        reg.usr("FAILOVER_FETCH", BtYes)
                    537:        reg.usrlist("MASTER_SORT", BtUnknown)
                    538:        reg.usrlist("MASTER_SORT_REGEX", BtUnknown)
                    539:        reg.usr("MASTER_SORT_RANDOM", BtYes)
                    540:        reg.usr("PKG_FC", BtShellCommand)
                    541:        reg.usrlist("IMAKEOPTS", BtShellWord)
                    542:        reg.usr("PRE_ROOT_CMD", BtShellCommand)
                    543:        reg.usr("SU_CMD", BtShellCommand)
                    544:        reg.usr("SU_CMD_PATH_APPEND", BtPathlist)
                    545:        reg.usr("FATAL_OBJECT_FMT_SKEW", BtYesNo)
                    546:        reg.usr("WARN_NO_OBJECT_FMT", BtYesNo)
                    547:        reg.usr("SMART_MESSAGES", BtYes)
                    548:        reg.usrlist("BINPKG_SITES", BtURL)
                    549:        reg.usrlist("BIN_INSTALL_FLAGS", BtShellWord)
                    550:        reg.usr("LOCALPATCHES", BtPathname)
                    551:
                    552:        reg.usr("ACROREAD_FONTPATH", BtPathlist)
                    553:        reg.usr("AMANDA_USER", BtUserGroupName)
                    554:        reg.usr("AMANDA_TMP", BtPathname)
                    555:        reg.usr("AMANDA_VAR", BtPathname)
                    556:        reg.usr("APACHE_USER", BtUserGroupName)
                    557:        reg.usr("APACHE_GROUP", BtUserGroupName)
                    558:        reg.usrlist("APACHE_SUEXEC_CONFIGURE_ARGS", BtShellWord)
                    559:        reg.usrlist("APACHE_SUEXEC_DOCROOT", BtPathname)
                    560:        reg.usr("ARLA_CACHE", BtPathname)
                    561:        reg.usr("BIND_DIR", BtPathname)
                    562:        reg.usr("BIND_GROUP", BtUserGroupName)
                    563:        reg.usr("BIND_USER", BtUserGroupName)
                    564:        reg.usr("CACTI_GROUP", BtUserGroupName)
                    565:        reg.usr("CACTI_USER", BtUserGroupName)
                    566:        reg.usr("CANNA_GROUP", BtUserGroupName)
                    567:        reg.usr("CANNA_USER", BtUserGroupName)
                    568:        reg.usr("CDRECORD_CONF", BtPathname)
                    569:        reg.usr("CLAMAV_GROUP", BtUserGroupName)
                    570:        reg.usr("CLAMAV_USER", BtUserGroupName)
                    571:        reg.usr("CLAMAV_DBDIR", BtPathname)
                    572:        reg.usr("CONSERVER_DEFAULTHOST", BtIdentifier)
                    573:        reg.usr("CONSERVER_DEFAULTPORT", BtInteger)
                    574:        reg.usr("CUPS_GROUP", BtUserGroupName)
                    575:        reg.usr("CUPS_USER", BtUserGroupName)
                    576:        reg.usrlist("CUPS_SYSTEM_GROUPS", BtUserGroupName)
                    577:        reg.usr("CYRUS_IDLE", enum("poll idled no"))
                    578:        reg.usr("CYRUS_GROUP", BtUserGroupName)
                    579:        reg.usr("CYRUS_USER", BtUserGroupName)
                    580:        reg.usr("DAEMONTOOLS_LOG_USER", BtUserGroupName)
                    581:        reg.usr("DAEMONTOOLS_GROUP", BtUserGroupName)
                    582:        reg.usr("DBUS_GROUP", BtUserGroupName)
                    583:        reg.usr("DBUS_USER", BtUserGroupName)
                    584:        reg.usr("DEFANG_GROUP", BtUserGroupName)
                    585:        reg.usr("DEFANG_USER", BtUserGroupName)
                    586:        reg.usr("DEFANG_SPOOLDIR", BtPathname)
                    587:        reg.usr("DEFAULT_IRC_SERVER", BtIdentifier)
                    588:        reg.usr("DEFAULT_SERIAL_DEVICE", BtPathname)
                    589:        reg.usr("DIALER_GROUP", BtUserGroupName)
                    590:        reg.usr("DJBDNS_AXFR_USER", BtUserGroupName)
                    591:        reg.usr("DJBDNS_CACHE_USER", BtUserGroupName)
                    592:        reg.usr("DJBDNS_LOG_USER", BtUserGroupName)
                    593:        reg.usr("DJBDNS_RBL_USER", BtUserGroupName)
                    594:        reg.usr("DJBDNS_TINY_USER", BtUserGroupName)
                    595:        reg.usr("DJBDNS_DJBDNS_GROUP", BtUserGroupName)
                    596:        reg.usr("DT_LAYOUT", enum("US FI FR GER DV"))
                    597:        reg.usrlist("ELK_GUI", enum("none xaw motif"))
                    598:        reg.usr("EMACS_TYPE", emacsVersions)
                    599:        reg.usr("EXIM_GROUP", BtUserGroupName)
                    600:        reg.usr("EXIM_USER", BtUserGroupName)
                    601:        reg.usrpkg("EXTRACT_USING", enum("bsdtar gtar nbtar pax"))
                    602:        reg.usrlist("FETCH_BEFORE_ARGS", BtShellWord)
                    603:        reg.usrlist("FETCH_AFTER_ARGS", BtShellWord)
                    604:        reg.usrlist("FETCH_RESUME_ARGS", BtShellWord)
                    605:        reg.usrlist("FETCH_OUTPUT_ARGS", BtShellWord)
                    606:        reg.usrpkg("FETCH_USING", enum("auto curl custom fetch ftp manual wget"))
                    607:        reg.usr("FLUXBOX_USE_XINERAMA", enum("YES NO"))
                    608:        reg.usr("FLUXBOX_USE_KDE", enum("YES NO"))
                    609:        reg.usr("FLUXBOX_USE_GNOME", enum("YES NO"))
                    610:        reg.usr("FLUXBOX_USE_XFT", enum("YES NO"))
                    611:        reg.usr("FOX_USE_XUNICODE", enum("YES NO"))
                    612:        reg.usr("FREEWNN_USER", BtUserGroupName)
                    613:        reg.usr("FREEWNN_GROUP", BtUserGroupName)
                    614:        reg.usr("GAMES_USER", BtUserGroupName)
                    615:        reg.usr("GAMES_GROUP", BtUserGroupName)
                    616:        reg.usr("GAMEMODE", BtFileMode)
                    617:        reg.usr("GAMEDIRMODE", BtFileMode)
                    618:        reg.usr("GAMEDATAMODE", BtFileMode)
                    619:        reg.usr("GAMEGRP", BtUserGroupName)
                    620:        reg.usr("GAMEOWN", BtUserGroupName)
                    621:        reg.usr("GRUB_NETWORK_CARDS", BtIdentifier)
                    622:        reg.usr("GRUB_PRESET_COMMAND", enum("bootp dhcp rarp"))
                    623:        reg.usrlist("GRUB_SCAN_ARGS", BtShellWord)
                    624:        reg.usr("HASKELL_COMPILER", enum("ghc"))
                    625:        reg.usr("HOWL_GROUP", BtUserGroupName)
                    626:        reg.usr("HOWL_USER", BtUserGroupName)
                    627:        reg.usr("ICECAST_CHROOTDIR", BtPathname)
                    628:        reg.usr("ICECAST_CHUNKLEN", BtInteger)
                    629:        reg.usr("ICECAST_SOURCE_BUFFSIZE", BtInteger)
                    630:        reg.usr("IMAP_UW_CCLIENT_MBOX_FMT",
1.57      rillig    631:                enum("mbox mbx mh mmdf mtx mx news phile tenex unix"))
1.73    ! rillig    632:        reg.usr("IMAP_UW_MAILSPOOLHOME", BtFilename)
1.67      rillig    633:        reg.usr("IMDICTDIR", BtPathname)
                    634:        reg.usr("INN_DATA_DIR", BtPathname)
                    635:        reg.usr("INN_USER", BtUserGroupName)
                    636:        reg.usr("INN_GROUP", BtUserGroupName)
                    637:        reg.usr("IRCD_HYBRID_NICLEN", BtInteger)
                    638:        reg.usr("IRCD_HYBRID_TOPICLEN", BtInteger)
                    639:        reg.usr("IRCD_HYBRID_SYSLOG_EVENTS", BtUnknown)
                    640:        reg.usr("IRCD_HYBRID_SYSLOG_FACILITY", BtIdentifier)
                    641:        reg.usr("IRCD_HYBRID_MAXCONN", BtInteger)
                    642:        reg.usr("IRCD_HYBRID_IRC_USER", BtUserGroupName)
                    643:        reg.usr("IRCD_HYBRID_IRC_GROUP", BtUserGroupName)
                    644:        reg.usr("IRRD_USE_PGP", enum("5 2"))
                    645:        reg.usr("JABBERD_USER", BtUserGroupName)
                    646:        reg.usr("JABBERD_GROUP", BtUserGroupName)
                    647:        reg.usr("JABBERD_LOGDIR", BtPathname)
                    648:        reg.usr("JABBERD_SPOOLDIR", BtPathname)
                    649:        reg.usr("JABBERD_PIDDIR", BtPathname)
                    650:        reg.usr("JAKARTA_HOME", BtPathname)
                    651:        reg.usr("KERBEROS", BtYes)
                    652:        reg.usr("KERMIT_SUID_UUCP", BtYes)
                    653:        reg.usr("KJS_USE_PCRE", BtYes)
                    654:        reg.usr("KNEWS_DOMAIN_FILE", BtPathname)
                    655:        reg.usr("KNEWS_DOMAIN_NAME", BtIdentifier)
                    656:        reg.usr("LIBDVDCSS_HOMEPAGE", BtHomepage)
                    657:        reg.usrlist("LIBDVDCSS_MASTER_SITES", BtFetchURL)
                    658:        reg.usr("LIBUSB_TYPE", enum("compat native"))
                    659:        reg.usr("LATEX2HTML_ICONPATH", BtURL)
                    660:        reg.usr("LEAFNODE_DATA_DIR", BtPathname)
                    661:        reg.usr("LEAFNODE_USER", BtUserGroupName)
                    662:        reg.usr("LEAFNODE_GROUP", BtUserGroupName)
                    663:        reg.usrlist("LINUX_LOCALES", BtIdentifier)
                    664:        reg.usr("MAILAGENT_DOMAIN", BtIdentifier)
                    665:        reg.usr("MAILAGENT_EMAIL", BtMailAddress)
                    666:        reg.usr("MAILAGENT_FQDN", BtIdentifier)
                    667:        reg.usr("MAILAGENT_ORGANIZATION", BtUnknown)
                    668:        reg.usr("MAJORDOMO_HOMEDIR", BtPathname)
                    669:        reg.usrlist("MAKEINFO_ARGS", BtShellWord)
                    670:        reg.usr("MECAB_CHARSET", BtIdentifier)
                    671:        reg.usr("MEDIATOMB_GROUP", BtUserGroupName)
                    672:        reg.usr("MEDIATOMB_USER", BtUserGroupName)
                    673:        reg.usr("MIREDO_USER", BtUserGroupName)
                    674:        reg.usr("MIREDO_GROUP", BtUserGroupName)
                    675:        reg.usr("MLDONKEY_GROUP", BtUserGroupName)
                    676:        reg.usr("MLDONKEY_HOME", BtPathname)
                    677:        reg.usr("MLDONKEY_USER", BtUserGroupName)
                    678:        reg.usr("MONOTONE_GROUP", BtUserGroupName)
                    679:        reg.usr("MONOTONE_USER", BtUserGroupName)
                    680:        reg.usr("MOTIF_TYPE", enum("motif openmotif lesstif dt"))
                    681:        reg.usr("MOTIF_TYPE_DEFAULT", enum("motif openmotif lesstif dt"))
                    682:        reg.usr("MTOOLS_ENABLE_FLOPPYD", BtYesNo)
                    683:        reg.usr("MYSQL_USER", BtUserGroupName)
                    684:        reg.usr("MYSQL_GROUP", BtUserGroupName)
                    685:        reg.usr("MYSQL_DATADIR", BtPathname)
                    686:        reg.usr("MYSQL_CHARSET", BtIdentifier)
                    687:        reg.usrlist("MYSQL_EXTRA_CHARSET", BtIdentifier)
                    688:        reg.usr("NAGIOS_GROUP", BtUserGroupName)
                    689:        reg.usr("NAGIOS_USER", BtUserGroupName)
                    690:        reg.usr("NAGIOSCMD_GROUP", BtUserGroupName)
                    691:        reg.usr("NAGIOSDIR", BtPathname)
                    692:        reg.usr("NBPAX_PROGRAM_PREFIX", BtUnknown)
                    693:        reg.usr("NMH_EDITOR", BtIdentifier)
                    694:        reg.usr("NMH_MTA", enum("smtp sendmail"))
                    695:        reg.usr("NMH_PAGER", BtIdentifier)
                    696:        reg.usr("NS_PREFERRED", enum("communicator navigator mozilla"))
                    697:        reg.usr("NULLMAILER_USER", BtUserGroupName)
                    698:        reg.usr("NULLMAILER_GROUP", BtUserGroupName)
                    699:        reg.usr("OPENSSH_CHROOT", BtPathname)
                    700:        reg.usr("OPENSSH_USER", BtUserGroupName)
                    701:        reg.usr("OPENSSH_GROUP", BtUserGroupName)
                    702:        reg.usr("P4USER", BtUserGroupName)
                    703:        reg.usr("P4GROUP", BtUserGroupName)
                    704:        reg.usr("P4ROOT", BtPathname)
                    705:        reg.usr("P4PORT", BtInteger)
                    706:        reg.usr("PALMOS_DEFAULT_SDK", enum("1 2 3.1 3.5"))
                    707:        reg.usr("PAPERSIZE", enum("A4 Letter"))
                    708:        reg.usr("PGGROUP", BtUserGroupName)
                    709:        reg.usr("PGUSER", BtUserGroupName)
                    710:        reg.usr("PGHOME", BtPathname)
                    711:        reg.usr("PILRC_USE_GTK", BtYesNo)
                    712:        reg.usr("PKG_JVM_DEFAULT", jvms)
                    713:        reg.usr("POPTOP_USE_MPPE", BtYes)
1.73    ! rillig    714:        reg.usr("PROCMAIL_MAILSPOOLHOME", BtFilename)
1.57      rillig    715:        // Comma-separated list of string or integer literals.
1.67      rillig    716:        reg.usr("PROCMAIL_TRUSTED_IDS", BtUnknown)
                    717:        reg.usr("PVM_SSH", BtPathname)
                    718:        reg.usr("QMAILDIR", BtPathname)
                    719:        reg.usr("QMAIL_ALIAS_USER", BtUserGroupName)
                    720:        reg.usr("QMAIL_DAEMON_USER", BtUserGroupName)
                    721:        reg.usr("QMAIL_LOG_USER", BtUserGroupName)
                    722:        reg.usr("QMAIL_ROOT_USER", BtUserGroupName)
                    723:        reg.usr("QMAIL_PASSWD_USER", BtUserGroupName)
                    724:        reg.usr("QMAIL_QUEUE_USER", BtUserGroupName)
                    725:        reg.usr("QMAIL_REMOTE_USER", BtUserGroupName)
                    726:        reg.usr("QMAIL_SEND_USER", BtUserGroupName)
                    727:        reg.usr("QMAIL_QMAIL_GROUP", BtUserGroupName)
                    728:        reg.usr("QMAIL_NOFILES_GROUP", BtUserGroupName)
                    729:        reg.usr("QMAIL_QFILTER_TMPDIR", BtPathname)
                    730:        reg.usr("QMAIL_QUEUE_DIR", BtPathname)
                    731:        reg.usr("QMAIL_QUEUE_EXTRA", BtMailAddress)
                    732:        reg.usr("QPOPPER_FAC", BtIdentifier)
                    733:        reg.usr("QPOPPER_USER", BtUserGroupName)
                    734:        reg.usr("QPOPPER_SPOOL_DIR", BtPathname)
                    735:        reg.usr("RASMOL_DEPTH", enum("8 16 32"))
                    736:        reg.usr("RELAY_CTRL_DIR", BtPathname)
                    737:        reg.usr("RPM_DB_PREFIX", BtPathname)
                    738:        reg.usr("RSSH_SCP_PATH", BtPathname)
                    739:        reg.usr("RSSH_SFTP_SERVER_PATH", BtPathname)
                    740:        reg.usr("RSSH_CVS_PATH", BtPathname)
                    741:        reg.usr("RSSH_RDIST_PATH", BtPathname)
                    742:        reg.usr("RSSH_RSYNC_PATH", BtPathname)
1.73    ! rillig    743:        reg.usrlist("SAWFISH_THEMES", BtFilename)
1.67      rillig    744:        reg.usr("SCREWS_GROUP", BtUserGroupName)
                    745:        reg.usr("SCREWS_USER", BtUserGroupName)
                    746:        reg.usr("SDIST_PAWD", enum("pawd pwd"))
                    747:        reg.usrlist("SERIAL_DEVICES", BtPathname)
                    748:        reg.usr("SILC_CLIENT_WITH_PERL", BtYesNo)
                    749:        reg.usr("SNIPROXY_USER", BtUserGroupName)
                    750:        reg.usr("SNIPROXY_GROUP", BtUserGroupName)
                    751:        reg.usr("SSH_SUID", BtYesNo)
                    752:        reg.usr("SSYNC_PAWD", enum("pawd pwd"))
                    753:        reg.usr("SUSE_PREFER", enum("13.1 12.1 10.0")) // TODO: extract
                    754:        reg.usr("TEXMFSITE", BtPathname)
                    755:        reg.usr("THTTPD_LOG_FACILITY", BtIdentifier)
                    756:        reg.usr("UCSPI_SSL_USER", BtUserGroupName)
                    757:        reg.usr("UCSPI_SSL_GROUP", BtUserGroupName)
                    758:        reg.usr("UNPRIVILEGED", BtYesNo)
                    759:        reg.usr("USE_CROSS_COMPILE", BtYesNo)
                    760:        reg.usr("USERPPP_GROUP", BtUserGroupName)
                    761:        reg.usr("UUCP_GROUP", BtUserGroupName)
                    762:        reg.usr("UUCP_USER", BtUserGroupName)
                    763:        reg.usrlist("VIM_EXTRA_OPTS", BtShellWord)
                    764:        reg.usr("WCALC_HTMLDIR", BtPathname)
                    765:        reg.usr("WCALC_HTMLPATH", BtPathname) // URL path
                    766:        reg.usr("WCALC_CGIDIR", BtPrefixPathname)
                    767:        reg.usr("WCALC_CGIPATH", BtPathname) // URL path
                    768:        reg.usrlist("WDM_MANAGERS", BtIdentifier)
                    769:        reg.usr("X10_PORT", BtPathname)
                    770:        reg.usrpkg("XAW_TYPE", enum("standard 3d xpm neXtaw"))
                    771:        reg.usr("XLOCK_DEFAULT_MODE", BtIdentifier)
                    772:        reg.usr("ZSH_STATIC", BtYes)
1.21      rillig    773:
1.1       rillig    774:        // some other variables, sorted alphabetically
                    775:
1.57      rillig    776:        // TODO: Instead of grouping them alphabetically, group them
                    777:        //  by topic, like clean, fetch, patch, configure, build, install,
                    778:        //  subst, buildlink3, checks. This will make them easier to
                    779:        //  analyze and align the permissions.
                    780:
1.67      rillig    781:        reg.sysload(".CURDIR", BtPathname)
                    782:        reg.sysload(".IMPSRC", BtPathname)
                    783:        reg.sys(".TARGET", BtPathname)
                    784:        reg.sys("@", BtPathname)
                    785:        reg.pkglistbl3("ALL_ENV", BtShellWord)
1.73    ! rillig    786:        reg.pkg("ALTERNATIVES_FILE", BtFilename)
1.67      rillig    787:        reg.pkglist("ALTERNATIVES_SRC", BtPathname)
                    788:        reg.pkg("APACHE_MODULE", BtYes)
                    789:        reg.sys("AR", BtShellCommand)
                    790:        reg.sys("AS", BtShellCommand)
                    791:        reg.pkglist("AUTOCONF_REQD", BtVersion)
1.73    ! rillig    792:        reg.pkglist("AUTOMAKE_OVERRIDE", BtPathPattern)
1.67      rillig    793:        reg.pkglist("AUTOMAKE_REQD", BtVersion)
                    794:        reg.pkg("AUTO_MKDIRS", BtYesNo)
                    795:        reg.usr("BATCH", BtYes)
                    796:        reg.usr("BDB185_DEFAULT", BtUnknown)
                    797:        reg.sys("BDBBASE", BtPathname)
                    798:        reg.pkglist("BDB_ACCEPTED", enum("db1 db2 db3 db4 db5 db6"))
                    799:        reg.usr("BDB_DEFAULT", enum("db1 db2 db3 db4 db5 db6"))
                    800:        reg.syslist("BDB_LIBS", BtLdFlag)
                    801:        reg.sys("BDB_TYPE", enum("db1 db2 db3 db4 db5 db6"))
                    802:        reg.syslist("BIGENDIANPLATFORMS", BtMachinePlatformPattern)
                    803:        reg.sys("BINGRP", BtUserGroupName)
                    804:        reg.sys("BINMODE", BtFileMode)
                    805:        reg.sys("BINOWN", BtUserGroupName)
                    806:        reg.pkglist("BOOTSTRAP_DEPENDS", BtDependencyWithPath)
                    807:        reg.pkg("BOOTSTRAP_PKG", BtYesNo)
1.57      rillig    808:        // BROKEN should better be a list of messages instead of a simple string.
1.68      rillig    809:        reg.pkgappend("BROKEN", BtMessage)
1.67      rillig    810:        reg.pkg("BROKEN_GETTEXT_DETECTION", BtYesNo)
                    811:        reg.pkglistrat("BROKEN_EXCEPT_ON_PLATFORM", BtMachinePlatformPattern)
                    812:        reg.pkglistrat("BROKEN_ON_PLATFORM", BtMachinePlatformPattern)
                    813:        reg.syslist("BSD_MAKE_ENV", BtShellWord)
1.52      rillig    814:        // TODO: Align the permissions of the various BUILDLINK_*.* variables with each other.
1.67      rillig    815:        reg.acllist("BUILDLINK_ABI_DEPENDS.*", BtDependency,
1.59      rillig    816:                PackageSettable,
1.57      rillig    817:                "buildlink3.mk, builtin.mk: append, use-loadtime",
                    818:                "*: append")
1.67      rillig    819:        reg.acllist("BUILDLINK_API_DEPENDS.*", BtDependency,
1.59      rillig    820:                PackageSettable,
1.57      rillig    821:                "buildlink3.mk, builtin.mk: append, use-loadtime",
                    822:                "*: append")
1.67      rillig    823:        reg.acl("BUILDLINK_AUTO_DIRS.*", BtYesNo,
1.59      rillig    824:                PackageSettable,
1.57      rillig    825:                "buildlink3.mk: append",
                    826:                "Makefile: set")
1.67      rillig    827:        reg.syslist("BUILDLINK_CFLAGS", BtCFlag)
                    828:        reg.bl3list("BUILDLINK_CFLAGS.*", BtCFlag)
                    829:        reg.acl("BUILDLINK_CONTENTS_FILTER.*", BtShellCommand,
1.59      rillig    830:                PackageSettable,
1.57      rillig    831:                "buildlink3.mk: set")
1.67      rillig    832:        reg.syslist("BUILDLINK_CPPFLAGS", BtCFlag)
                    833:        reg.bl3list("BUILDLINK_CPPFLAGS.*", BtCFlag)
                    834:        reg.acllist("BUILDLINK_DEPENDS", BtIdentifier,
1.59      rillig    835:                PackageSettable,
1.57      rillig    836:                "buildlink3.mk: append")
1.67      rillig    837:        reg.acllist("BUILDLINK_DEPMETHOD.*", BtBuildlinkDepmethod,
1.59      rillig    838:                PackageSettable,
1.57      rillig    839:                "buildlink3.mk: default, append, use",
                    840:                "Makefile, Makefile.*, *.mk: default, set, append")
1.67      rillig    841:        reg.acl("BUILDLINK_DIR", BtPathname,
1.59      rillig    842:                PackageSettable,
1.57      rillig    843:                "*: use")
1.73    ! rillig    844:        reg.bl3list("BUILDLINK_FILES.*", BtPathPattern)
1.67      rillig    845:        reg.pkgbl3("BUILDLINK_FILES_CMD.*", BtShellCommand)
                    846:        reg.acllist("BUILDLINK_INCDIRS.*", BtPathname,
1.59      rillig    847:                PackageSettable,
1.57      rillig    848:                "buildlink3.mk: default, append",
                    849:                "Makefile, Makefile.*, *.mk: use")
1.67      rillig    850:        reg.acl("BUILDLINK_JAVA_PREFIX.*", BtPathname,
1.59      rillig    851:                PackageSettable,
1.57      rillig    852:                "buildlink3.mk: set, use")
1.67      rillig    853:        reg.acllist("BUILDLINK_LDADD.*", BtLdFlag,
1.59      rillig    854:                PackageSettable,
1.57      rillig    855:                "builtin.mk: default, set, append, use",
                    856:                "buildlink3.mk: append, use",
                    857:                "Makefile, Makefile.*, *.mk: use")
1.67      rillig    858:        reg.acllist("BUILDLINK_LDFLAGS", BtLdFlag,
1.59      rillig    859:                PackageSettable,
1.57      rillig    860:                "*: use")
1.67      rillig    861:        reg.bl3list("BUILDLINK_LDFLAGS.*", BtLdFlag)
                    862:        reg.acllist("BUILDLINK_LIBDIRS.*", BtPathname,
1.59      rillig    863:                PackageSettable,
1.57      rillig    864:                "buildlink3.mk, builtin.mk: append",
                    865:                "Makefile, Makefile.*, *.mk: use")
1.67      rillig    866:        reg.acllist("BUILDLINK_LIBS.*", BtLdFlag,
1.59      rillig    867:                PackageSettable,
1.57      rillig    868:                "buildlink3.mk: append",
                    869:                "Makefile, Makefile.*, *.mk: set, append, use")
1.67      rillig    870:        reg.acllist("BUILDLINK_PASSTHRU_DIRS", BtPathname,
1.59      rillig    871:                PackageSettable,
1.57      rillig    872:                "Makefile, Makefile.*, *.mk: append")
1.67      rillig    873:        reg.acllist("BUILDLINK_PASSTHRU_RPATHDIRS", BtPathname,
1.59      rillig    874:                PackageSettable,
1.57      rillig    875:                "Makefile, Makefile.*, *.mk: append")
1.67      rillig    876:        reg.acl("BUILDLINK_PKGSRCDIR.*", BtRelativePkgDir,
1.59      rillig    877:                PackageSettable,
1.57      rillig    878:                "buildlink3.mk: default, use-loadtime")
1.67      rillig    879:        reg.acl("BUILDLINK_PREFIX.*", BtPathname,
1.59      rillig    880:                PackageSettable,
1.57      rillig    881:                "builtin.mk: set, use",
                    882:                "Makefile, Makefile.*, *.mk: use")
1.67      rillig    883:        reg.acllist("BUILDLINK_RPATHDIRS.*", BtPathname,
1.59      rillig    884:                PackageSettable,
1.57      rillig    885:                "buildlink3.mk: append")
1.67      rillig    886:        reg.acllist("BUILDLINK_TARGETS", BtIdentifier,
1.59      rillig    887:                PackageSettable,
1.57      rillig    888:                "Makefile, Makefile.*, *.mk: append")
1.67      rillig    889:        reg.acl("BUILDLINK_FNAME_TRANSFORM.*", BtSedCommands,
1.59      rillig    890:                PackageSettable,
1.60      rillig    891:                "Makefile, buildlink3.mk, builtin.mk, options.mk: append")
1.67      rillig    892:        reg.acllist("BUILDLINK_TRANSFORM", BtWrapperTransform,
1.59      rillig    893:                PackageSettable,
1.57      rillig    894:                "*: append")
1.67      rillig    895:        reg.acllist("BUILDLINK_TRANSFORM.*", BtWrapperTransform,
1.59      rillig    896:                PackageSettable,
1.57      rillig    897:                "*: append")
1.67      rillig    898:        reg.acllist("BUILDLINK_TREE", BtIdentifier,
1.59      rillig    899:                PackageSettable,
1.57      rillig    900:                "buildlink3.mk: append")
1.67      rillig    901:        reg.acl("BUILDLINK_X11_DIR", BtPathname,
1.59      rillig    902:                PackageSettable,
1.57      rillig    903:                "*: use")
1.67      rillig    904:        reg.acllist("BUILD_DEFS", BtVariableName,
1.59      rillig    905:                PackageSettable,
1.57      rillig    906:                "Makefile, Makefile.*, *.mk: append")
1.67      rillig    907:        reg.pkglist("BUILD_DEFS_EFFECTS", BtVariableName)
                    908:        reg.pkglistbl3("BUILD_DEPENDS", BtDependencyWithPath)
                    909:        reg.pkglist("BUILD_DIRS", BtWrksrcSubdirectory)
                    910:        reg.pkglist("BUILD_ENV", BtShellWord)
                    911:        reg.sys("BUILD_MAKE_CMD", BtShellCommand)
                    912:        reg.pkglist("BUILD_MAKE_FLAGS", BtShellWord)
                    913:        reg.pkglist("BUILD_TARGET", BtIdentifier)
                    914:        reg.pkglist("BUILD_TARGET.*", BtIdentifier)
                    915:        reg.pkg("BUILD_USES_MSGFMT", BtYes)
                    916:        reg.acl("BUILTIN_PKG", BtIdentifier,
1.59      rillig    917:                PackageSettable,
1.57      rillig    918:                "builtin.mk: set, use, use-loadtime",
                    919:                "Makefile, Makefile.*, *.mk: use, use-loadtime")
1.73    ! rillig    920:        reg.acl("BUILTIN_PKG.*", BtPkgname,
1.59      rillig    921:                PackageSettable,
1.57      rillig    922:                "builtin.mk: set, use, use-loadtime")
1.67      rillig    923:        reg.pkglistbl3("BUILTIN_FIND_FILES_VAR", BtVariableName)
                    924:        reg.pkglistbl3("BUILTIN_FIND_FILES.*", BtPathname)
                    925:        reg.acl("BUILTIN_FIND_GREP.*", BtUnknown,
1.59      rillig    926:                PackageSettable,
1.57      rillig    927:                "builtin.mk: set")
1.67      rillig    928:        reg.acllist("BUILTIN_FIND_HEADERS_VAR", BtVariableName,
1.59      rillig    929:                PackageSettable,
1.57      rillig    930:                "builtin.mk: set")
1.67      rillig    931:        reg.acllist("BUILTIN_FIND_HEADERS.*", BtPathname,
1.59      rillig    932:                PackageSettable,
1.57      rillig    933:                "builtin.mk: set")
1.67      rillig    934:        reg.acllist("BUILTIN_FIND_LIBS", BtPathname,
1.59      rillig    935:                PackageSettable,
1.57      rillig    936:                "builtin.mk: set")
1.67      rillig    937:        reg.sys("BUILTIN_X11_TYPE", BtUnknown)
                    938:        reg.sys("BUILTIN_X11_VERSION", BtUnknown)
                    939:        reg.pkglist("CATEGORIES", BtCategory)
                    940:        reg.sysload("CC_VERSION", BtMessage)
                    941:        reg.sysload("CC", BtShellCommand)
                    942:        reg.pkglistbl3("CFLAGS", BtCFlag)   // may also be changed by the user
                    943:        reg.pkglistbl3("CFLAGS.*", BtCFlag) // may also be changed by the user
                    944:        reg.acl("CHECK_BUILTIN", BtYesNo,
1.59      rillig    945:                PackageSettable,
1.57      rillig    946:                "builtin.mk: default",
                    947:                "Makefile: set")
1.67      rillig    948:        reg.acl("CHECK_BUILTIN.*", BtYesNo,
1.59      rillig    949:                PackageSettable,
1.57      rillig    950:                "Makefile, options.mk, buildlink3.mk: set",
                    951:                "builtin.mk: default, use-loadtime",
                    952:                "*: use-loadtime")
1.67      rillig    953:        reg.pkglist("CHECK_FILES_SKIP", BtBasicRegularExpression)
                    954:        reg.pkg("CHECK_FILES_SUPPORTED", BtYesNo)
                    955:        reg.usr("CHECK_HEADERS", BtYesNo)
1.73    ! rillig    956:        reg.pkglist("CHECK_HEADERS_SKIP", BtPathPattern)
1.67      rillig    957:        reg.usr("CHECK_INTERPRETER", BtYesNo)
1.73    ! rillig    958:        reg.pkglist("CHECK_INTERPRETER_SKIP", BtPathPattern)
1.67      rillig    959:        reg.usr("CHECK_PERMS", BtYesNo)
1.73    ! rillig    960:        reg.pkglist("CHECK_PERMS_SKIP", BtPathPattern)
1.67      rillig    961:        reg.usr("CHECK_PORTABILITY", BtYesNo)
1.73    ! rillig    962:        reg.pkglist("CHECK_PORTABILITY_SKIP", BtPathPattern)
1.67      rillig    963:        reg.usr("CHECK_RELRO", BtYesNo)
1.73    ! rillig    964:        reg.pkglist("CHECK_RELRO_SKIP", BtPathPattern)
1.67      rillig    965:        reg.pkg("CHECK_RELRO_SUPPORTED", BtYesNo)
                    966:        reg.pkg("CHECK_SHLIBS", BtYesNo)
1.73    ! rillig    967:        reg.pkglist("CHECK_SHLIBS_SKIP", BtPathPattern)
1.67      rillig    968:        reg.pkg("CHECK_SHLIBS_SUPPORTED", BtYesNo)
1.73    ! rillig    969:        reg.pkglist("CHECK_WRKREF_SKIP", BtPathPattern)
1.67      rillig    970:        reg.pkg("CMAKE_ARG_PATH", BtPathname)
                    971:        reg.pkglist("CMAKE_ARGS", BtShellWord)
                    972:        reg.pkglist("CMAKE_ARGS.*", BtShellWord)
1.73    ! rillig    973:        reg.pkglist("CMAKE_DEPENDENCIES_REWRITE", BtPathPattern) // Relative to WRKSRC
        !           974:        reg.pkglist("CMAKE_MODULE_PATH_OVERRIDE", BtPathPattern) // Relative to WRKSRC
1.67      rillig    975:        reg.pkg("CMAKE_PKGSRC_BUILD_FLAGS", BtYesNo)
1.73    ! rillig    976:        reg.pkglist("CMAKE_PREFIX_PATH", BtPathPattern)
1.67      rillig    977:        reg.pkg("CMAKE_USE_GNU_INSTALL_DIRS", BtYesNo)
                    978:        reg.pkg("CMAKE_INSTALL_PREFIX", BtPathname) // The default is ${PREFIX}.
                    979:        reg.pkgappend("COMMENT", BtComment)
                    980:        reg.sys("COMPILE.*", BtShellCommand)
                    981:        reg.sys("COMPILER_RPATH_FLAG", enum("-Wl,-rpath"))
                    982:        reg.pkglist("CONFIGURE_ARGS", BtShellWord)
                    983:        reg.pkglist("CONFIGURE_ARGS.*", BtShellWord)
                    984:        reg.pkglist("CONFIGURE_DIRS", BtWrksrcSubdirectory)
                    985:        reg.pkglistbl3("CONFIGURE_ENV", BtShellWord)
                    986:        reg.pkglistbl3("CONFIGURE_ENV.*", BtShellWord)
                    987:        reg.pkg("CONFIGURE_HAS_INFODIR", BtYesNo)
                    988:        reg.pkg("CONFIGURE_HAS_LIBDIR", BtYesNo)
                    989:        reg.pkg("CONFIGURE_HAS_MANDIR", BtYesNo)
                    990:        reg.pkg("CONFIGURE_SCRIPT", BtPathname)
1.73    ! rillig    991:        reg.pkglist("CONFIG_GUESS_OVERRIDE", BtPathPattern)
        !           992:        reg.pkglist("CONFIG_STATUS_OVERRIDE", BtPathPattern)
1.67      rillig    993:        reg.pkg("CONFIG_SHELL", BtPathname)
1.73    ! rillig    994:        reg.pkglist("CONFIG_SUB_OVERRIDE", BtPathPattern)
1.67      rillig    995:        reg.pkglist("CONFLICTS", BtDependency)
                    996:        reg.pkgappend("CONF_FILES", BtConfFiles)
                    997:        reg.pkg("CONF_FILES_MODE", enum("0644 0640 0600 0400"))
                    998:        reg.pkglist("CONF_FILES_PERMS", BtPerms)
                    999:        reg.sys("COPY", enum("-c")) // The flag that tells ${INSTALL} to copy a file
                   1000:        reg.sys("CPP", BtShellCommand)
                   1001:        reg.pkglistbl3("CPPFLAGS", BtCFlag)
                   1002:        reg.pkglistbl3("CPPFLAGS.*", BtCFlag)
                   1003:        reg.sys("CXX", BtShellCommand)
                   1004:        reg.pkglistbl3("CXXFLAGS", BtCFlag)
                   1005:        reg.pkglistbl3("CXXFLAGS.*", BtCFlag)
                   1006:        reg.pkglistbl3("CWRAPPERS_APPEND.*", BtShellWord)
                   1007:        reg.syslist("DEFAULT_DISTFILES", BtFetchURL) // From mk/fetch/bsd.fetch-vars.mk.
                   1008:        reg.pkglist("DEINSTALL_SRC", BtPathname)
                   1009:        reg.pkglist("DEINSTALL_TEMPLATES", BtPathname)
                   1010:        reg.sys("DELAYED_ERROR_MSG", BtShellCommand)
                   1011:        reg.sys("DELAYED_WARNING_MSG", BtShellCommand)
                   1012:        reg.pkglistbl3("DEPENDS", BtDependencyWithPath)
                   1013:        reg.usrlist("DEPENDS_TARGET", BtIdentifier)
                   1014:        reg.pkglist("DESCR_SRC", BtPathname)
                   1015:        reg.sys("DESTDIR", BtPathname)
                   1016:        reg.pkg("DESTDIR_VARNAME", BtVariableName)
                   1017:        reg.sys("DEVOSSAUDIO", BtPathname)
                   1018:        reg.sys("DEVOSSSOUND", BtPathname)
1.73    ! rillig   1019:        reg.pkglist("DISTFILES", BtFilename)
1.67      rillig   1020:        reg.pkg("DISTINFO_FILE", BtRelativePkgPath)
1.73    ! rillig   1021:        reg.pkg("DISTNAME", BtFilename)
1.67      rillig   1022:        reg.pkg("DIST_SUBDIR", BtPathname)
                   1023:        reg.pkglist("DJB_BUILD_ARGS", BtShellWord)
                   1024:        reg.pkglist("DJB_BUILD_TARGETS", BtIdentifier)
                   1025:        reg.pkgappend("DJB_CONFIG_CMDS", BtShellCommands)
                   1026:        reg.pkglist("DJB_CONFIG_DIRS", BtWrksrcSubdirectory)
1.73    ! rillig   1027:        reg.pkg("DJB_CONFIG_HOME", BtFilename)
1.67      rillig   1028:        reg.pkg("DJB_CONFIG_PREFIX", BtPathname)
                   1029:        reg.pkglist("DJB_INSTALL_TARGETS", BtIdentifier)
                   1030:        reg.pkg("DJB_MAKE_TARGETS", BtYesNo)
                   1031:        reg.pkg("DJB_RESTRICTED", BtYesNo)
                   1032:        reg.pkg("DJB_SLASHPACKAGE", BtYesNo)
                   1033:        reg.pkg("DLOPEN_REQUIRE_PTHREADS", BtYesNo)
                   1034:        reg.pkg("DL_AUTO_VARS", BtYes)
                   1035:        reg.acllist("DL_LIBS", BtLdFlag,
1.59      rillig   1036:                PackageSettable,
1.57      rillig   1037:                "*: append, use")
1.67      rillig   1038:        reg.sys("DOCOWN", BtUserGroupName)
                   1039:        reg.sys("DOCGRP", BtUserGroupName)
                   1040:        reg.sys("DOCMODE", BtFileMode)
                   1041:        reg.sys("DOWNLOADED_DISTFILE", BtPathname)
                   1042:        reg.sys("DO_NADA", BtShellCommand)
                   1043:        reg.pkg("DYNAMIC_SITES_CMD", BtShellCommand)
                   1044:        reg.pkg("DYNAMIC_SITES_SCRIPT", BtPathname)
                   1045:        reg.sysbl3("ECHO", BtShellCommand)
1.72      rillig   1046:        reg.sysbl3("ECHO_BUILDLINK_MSG", BtShellCommand)
1.67      rillig   1047:        reg.sysbl3("ECHO_MSG", BtShellCommand)
                   1048:        reg.sysbl3("ECHO_N", BtShellCommand)
                   1049:        reg.pkg("EGDIR", BtPathname) // Not defined anywhere but used in many places like this.
                   1050:        reg.sys("EMACS_BIN", BtPathname)
                   1051:        reg.sys("EMACS_ETCPREFIX", BtPathname)
                   1052:        reg.sys("EMACS_FLAVOR", enum("emacs xemacs"))
                   1053:        reg.sys("EMACS_INFOPREFIX", BtPathname)
                   1054:        reg.sys("EMACS_LISPPREFIX", BtPathname)
                   1055:        reg.pkglistbl3("EMACS_MODULES", BtIdentifier)
                   1056:        reg.sys("EMACS_PKGNAME_PREFIX", BtIdentifier) // Or the empty string.
                   1057:        reg.pkglist("EMACS_VERSIONS_ACCEPTED", emacsVersions)
                   1058:        reg.sys("EMACS_VERSION_MAJOR", BtInteger)
                   1059:        reg.sys("EMACS_VERSION_MINOR", BtInteger)
                   1060:        reg.pkglistrat("EMACS_VERSION_REQD", emacsVersions)
                   1061:        reg.sys("EMULDIR", BtPathname)
                   1062:        reg.sys("EMULSUBDIR", BtPathname)
                   1063:        reg.sys("OPSYS_EMULDIR", BtPathname)
                   1064:        reg.sys("EMULSUBDIRSLASH", BtPathname)
                   1065:        reg.sys("EMUL_ARCH", enum("arm i386 m68k none ns32k sparc vax x86_64"))
                   1066:        reg.sys("EMUL_DISTRO", BtIdentifier)
                   1067:        reg.sys("EMUL_IS_NATIVE", BtYes)
                   1068:        reg.pkglist("EMUL_MODULES.*", BtIdentifier)
                   1069:        reg.sys("EMUL_OPSYS", enum("darwin freebsd hpux irix linux osf1 solaris sunos none"))
                   1070:        reg.pkg("EMUL_PKG_FMT", enum("plain rpm"))
                   1071:        reg.usr("EMUL_PLATFORM", BtEmulPlatform)
                   1072:        reg.pkglist("EMUL_PLATFORMS", BtEmulPlatform)
                   1073:        reg.usrlist("EMUL_PREFER", BtEmulPlatform)
                   1074:        reg.pkglist("EMUL_REQD", BtDependency)
                   1075:        reg.usr("EMUL_TYPE.*", enum("native builtin suse suse-10.0 suse-12.1 suse-13.1"))
                   1076:        reg.sys("ERROR_CAT", BtShellCommand)
                   1077:        reg.sys("ERROR_MSG", BtShellCommand)
                   1078:        reg.syslist("EXPORT_SYMBOLS_LDFLAGS", BtLdFlag)
                   1079:        reg.sys("EXTRACT_CMD", BtShellCommand)
                   1080:        reg.pkg("EXTRACT_DIR", BtPathname)
                   1081:        reg.pkg("EXTRACT_DIR.*", BtPathname)
1.73    ! rillig   1082:        reg.pkglist("EXTRACT_ELEMENTS", BtPathPattern)
1.67      rillig   1083:        reg.pkglist("EXTRACT_ENV", BtShellWord)
                   1084:        reg.pkglist("EXTRACT_ONLY", BtPathname)
                   1085:        reg.pkglist("EXTRACT_OPTS", BtShellWord)
                   1086:        reg.pkglist("EXTRACT_OPTS_BIN", BtShellWord)
                   1087:        reg.pkglist("EXTRACT_OPTS_LHA", BtShellWord)
                   1088:        reg.pkglist("EXTRACT_OPTS_PAX", BtShellWord)
                   1089:        reg.pkglist("EXTRACT_OPTS_RAR", BtShellWord)
                   1090:        reg.pkglist("EXTRACT_OPTS_TAR", BtShellWord)
                   1091:        reg.pkglist("EXTRACT_OPTS_ZIP", BtShellWord)
                   1092:        reg.pkglist("EXTRACT_OPTS_ZOO", BtShellWord)
                   1093:        reg.pkg("EXTRACT_SUFX", BtDistSuffix)
                   1094:        reg.sys("FAIL_MSG", BtShellCommand)
                   1095:        reg.sys("FAMBASE", BtPathname)
                   1096:        reg.pkglist("FAM_ACCEPTED", enum("fam gamin"))
                   1097:        reg.usr("FAM_DEFAULT", enum("fam gamin"))
                   1098:        reg.sys("FAM_TYPE", enum("fam gamin"))
                   1099:        reg.pkglist("FETCH_MESSAGE", BtShellWord)
                   1100:        reg.pkgload("FILESDIR", BtRelativePkgPath)
                   1101:        reg.pkglist("FILES_SUBST", BtShellWord)
                   1102:        reg.syslist("FILES_SUBST_SED", BtShellWord)
                   1103:        reg.pkglist("FIX_RPATH", BtVariableName)
                   1104:        reg.pkglistrat("FLEX_REQD", BtVersion)
                   1105:        reg.pkglist("FONTS_DIRS.*", BtPathname)
                   1106:        reg.syslist("GAMEDATA_PERMS", BtPerms)
                   1107:        reg.syslist("GAMEDIR_PERMS", BtPerms)
                   1108:        reg.pkglistbl3rat("GCC_REQD", BtGccReqd)
                   1109:        reg.pkgappend("GENERATE_PLIST", BtShellCommands)
                   1110:        reg.pkg("GITHUB_PROJECT", BtIdentifier)
                   1111:        reg.pkg("GITHUB_TAG", BtIdentifier)
1.73    ! rillig   1112:        reg.pkg("GITHUB_RELEASE", BtFilename)
1.67      rillig   1113:        reg.pkg("GITHUB_TYPE", enum("tag release"))
                   1114:        reg.pkgrat("GMAKE_REQD", BtVersion)
1.57      rillig   1115:        // Some packages need to set GNU_ARCH.i386 to either i486 or i586.
1.67      rillig   1116:        reg.pkg("GNU_ARCH.*", BtIdentifier)
1.57      rillig   1117:        // GNU_CONFIGURE needs to be tested in some buildlink3.mk files,
                   1118:        // such as lang/vala.
1.67      rillig   1119:        reg.acl("GNU_CONFIGURE", BtYes,
1.59      rillig   1120:                PackageSettable,
1.57      rillig   1121:                "buildlink3.mk: none",
                   1122:                "builtin.mk: use, use-loadtime",
                   1123:                "Makefile, Makefile.*, *.mk: default, set, use, use-loadtime")
1.67      rillig   1124:        reg.pkg("GNU_CONFIGURE_INFODIR", BtPathname)
                   1125:        reg.pkg("GNU_CONFIGURE_LIBDIR", BtPathname)
                   1126:        reg.pkg("GNU_CONFIGURE_LIBSUBDIR", BtPathname)
                   1127:        reg.pkg("GNU_CONFIGURE_MANDIR", BtPathname)
                   1128:        reg.pkg("GNU_CONFIGURE_PREFIX", BtPathname)
                   1129:        reg.pkg("GOPATH", BtPathname)
                   1130:        reg.pkgload("HAS_CONFIGURE", BtYes)
                   1131:        reg.pkglist("HEADER_TEMPLATES", BtPathname)
                   1132:        reg.pkg("HOMEPAGE", BtHomepage)
1.68      rillig   1133:        reg.pkgbl3("ICON_THEMES", BtYes)
1.67      rillig   1134:        reg.acl("IGNORE_PKG.*", BtYes,
1.59      rillig   1135:                PackageSettable,
1.57      rillig   1136:                "*: set, use-loadtime")
1.67      rillig   1137:        reg.sys("IMAKE", BtShellCommand)
                   1138:        reg.pkglistbl3rat("INCOMPAT_CURSES", BtMachinePlatformPattern)
                   1139:        reg.sys("INFO_DIR", BtPathname) // relative to PREFIX
                   1140:        reg.pkg("INFO_FILES", BtYes)
1.71      rillig   1141:        reg.sys("INFO_MSG", BtShellCommand)
1.67      rillig   1142:        reg.sys("INSTALL", BtShellCommand)
                   1143:        reg.pkglist("INSTALLATION_DIRS", BtPrefixPathname)
                   1144:        reg.pkg("INSTALLATION_DIRS_FROM_PLIST", BtYes)
                   1145:        reg.sys("INSTALL_DATA", BtShellCommand)
                   1146:        reg.sys("INSTALL_DATA_DIR", BtShellCommand)
                   1147:        reg.pkglist("INSTALL_DIRS", BtWrksrcSubdirectory)
                   1148:        reg.pkglist("INSTALL_ENV", BtShellWord)
                   1149:        reg.pkg("INSTALL_FILE", BtPathname)
                   1150:        reg.sys("INSTALL_GAME", BtShellCommand)
                   1151:        reg.sys("INSTALL_GAME_DATA", BtShellCommand)
                   1152:        reg.sys("INSTALL_LIB", BtShellCommand)
                   1153:        reg.sys("INSTALL_LIB_DIR", BtShellCommand)
                   1154:        reg.pkglist("INSTALL_MAKE_FLAGS", BtShellWord)
                   1155:        reg.sys("INSTALL_MAN", BtShellCommand)
                   1156:        reg.sys("INSTALL_MAN_DIR", BtShellCommand)
                   1157:        reg.sys("INSTALL_PROGRAM", BtShellCommand)
                   1158:        reg.sys("INSTALL_PROGRAM_DIR", BtShellCommand)
                   1159:        reg.sys("INSTALL_SCRIPT", BtShellCommand)
                   1160:        reg.syslist("INSTALL_SCRIPTS_ENV", BtShellWord)
                   1161:        reg.sys("INSTALL_SCRIPT_DIR", BtShellCommand)
                   1162:        reg.pkglist("INSTALL_SRC", BtPathname)
                   1163:        reg.pkglist("INSTALL_TARGET", BtIdentifier)
                   1164:        reg.pkglist("INSTALL_TEMPLATES", BtPathname)
                   1165:        reg.pkgload("INSTALL_UNSTRIPPED", BtYesNo)
                   1166:        reg.pkglist("INTERACTIVE_STAGE", enum("fetch extract configure build test install"))
                   1167:        reg.acl("IS_BUILTIN.*", BtYesNoIndirectly,
1.59      rillig   1168:                PackageSettable,
1.57      rillig   1169:                // These two differ from the standard,
                   1170:                // they are needed for devel/ncursesw.
                   1171:                "buildlink3.mk: use, use-loadtime",
                   1172:                // The "set" differs from the standard sys.
                   1173:                "builtin.mk: set, use, use-loadtime",
                   1174:                "Makefile, Makefile.*, *.mk: default, set, use, use-loadtime")
1.67      rillig   1175:        reg.sys("JAVA_BINPREFIX", BtPathname)
                   1176:        reg.pkg("JAVA_CLASSPATH", BtShellWord)
                   1177:        reg.pkg("JAVA_HOME", BtPathname)
1.73    ! rillig   1178:        reg.pkg("JAVA_NAME", BtFilename)
1.67      rillig   1179:        reg.pkglist("JAVA_UNLIMIT", enum("cmdsize datasize stacksize"))
1.73    ! rillig   1180:        reg.pkglist("JAVA_WRAPPERS", BtFilename)
1.67      rillig   1181:        reg.pkg("JAVA_WRAPPER_BIN.*", BtPathname)
                   1182:        reg.sys("KRB5BASE", BtPathname)
                   1183:        reg.pkglist("KRB5_ACCEPTED", enum("heimdal mit-krb5"))
                   1184:        reg.usr("KRB5_DEFAULT", enum("heimdal mit-krb5"))
                   1185:        reg.sys("KRB5_TYPE", BtIdentifier)
                   1186:        reg.sys("LD", BtShellCommand)
                   1187:        reg.pkglistbl3("LDFLAGS", BtLdFlag)       // May also be changed by the user.
                   1188:        reg.pkglistbl3("LDFLAGS.*", BtLdFlag)     // May also be changed by the user.
                   1189:        reg.sysload("LIBABISUFFIX", BtIdentifier) // Can also be empty.
                   1190:        reg.sys("LIBGRP", BtUserGroupName)
                   1191:        reg.sys("LIBMODE", BtFileMode)
                   1192:        reg.sys("LIBOWN", BtUserGroupName)
                   1193:        reg.sys("LIBOSSAUDIO", BtPathname)
                   1194:        reg.pkglist("LIBS", BtLdFlag)
                   1195:        reg.pkglist("LIBS.*", BtLdFlag)
                   1196:        reg.sys("LIBTOOL", BtShellCommand)
1.73    ! rillig   1197:        reg.pkglist("LIBTOOL_OVERRIDE", BtPathPattern)
1.67      rillig   1198:        reg.pkglistrat("LIBTOOL_REQD", BtVersion)
                   1199:        reg.pkgappend("LICENCE", BtLicense)
                   1200:        reg.pkgappend("LICENSE", BtLicense)
                   1201:        reg.pkg("LICENSE_FILE", BtPathname)
                   1202:        reg.sys("LINK.*", BtShellCommand)
                   1203:        reg.sys("LINKER_RPATH_FLAG", BtShellWord)
                   1204:        reg.syslist("LITTLEENDIANPLATFORMS", BtMachinePlatformPattern)
                   1205:        reg.sys("LOWER_OPSYS", BtIdentifier)
                   1206:        reg.sys("LOWER_VENDOR", BtIdentifier)
                   1207:        reg.syslist("LP64PLATFORMS", BtMachinePlatformPattern)
1.73    ! rillig   1208:        reg.pkglist("LTCONFIG_OVERRIDE", BtPathPattern)
1.67      rillig   1209:        reg.sysload("MACHINE_ARCH", enumMachineArch)
                   1210:        reg.sysload("MACHINE_GNU_ARCH", enumMachineGnuArch)
                   1211:        reg.sysload("MACHINE_GNU_PLATFORM", BtMachineGnuPlatform)
                   1212:        reg.sysload("MACHINE_PLATFORM", BtMachinePlatform)
                   1213:        reg.pkg("MAINTAINER", BtMailAddress)
                   1214:        reg.sysload("MAKE", BtShellCommand)
                   1215:        reg.pkglist("MAKEFLAGS", BtShellWord)
                   1216:        reg.pkglistbl3("MAKEVARS", BtVariableName)
                   1217:        reg.pkglist("MAKE_DIRS", BtPathname)
                   1218:        reg.pkglist("MAKE_DIRS_PERMS", BtPerms)
                   1219:        reg.pkglistbl3("MAKE_ENV", BtShellWord)
                   1220:        reg.pkglistbl3("MAKE_ENV.*", BtShellWord)
                   1221:        reg.pkg("MAKE_FILE", BtPathname)
                   1222:        reg.pkglist("MAKE_FLAGS", BtShellWord)
                   1223:        reg.pkglist("MAKE_FLAGS.*", BtShellWord)
                   1224:        reg.pkgrat("MAKE_JOBS_SAFE", BtYesNo)
                   1225:        reg.pkg("MAKE_PROGRAM", BtShellCommand)
                   1226:        reg.pkg("MANCOMPRESSED", BtYesNo)
                   1227:        reg.pkg("MANCOMPRESSED_IF_MANZ", BtYes)
                   1228:        reg.sys("MANGRP", BtUserGroupName)
                   1229:        reg.sys("MANMODE", BtFileMode)
                   1230:        reg.sys("MANOWN", BtUserGroupName)
                   1231:        reg.pkglist("MASTER_SITES", BtFetchURL)
1.64      rillig   1232:
                   1233:        for _, filename := range []string{"mk/fetch/sites.mk", "mk/fetch/fetch.mk"} {
1.71      rillig   1234:                sitesMk := src.LoadMkInfra(filename, NotEmpty|MustSucceed)
1.64      rillig   1235:                if sitesMk != nil {
1.68      rillig   1236:                        sitesMk.ForEach(func(mkline *MkLine) {
1.64      rillig   1237:                                if mkline.IsVarassign() && hasPrefix(mkline.Varname(), "MASTER_SITE_") {
1.67      rillig   1238:                                        reg.syslist(mkline.Varname(), BtFetchURL)
1.64      rillig   1239:                                }
                   1240:                        })
                   1241:                }
1.68      rillig   1242:
                   1243:                // During tests, use t.SetUpMasterSite instead to declare these variables.
1.64      rillig   1244:        }
                   1245:
1.67      rillig   1246:        reg.pkglist("MESSAGE_SRC", BtPathname)
                   1247:        reg.pkglist("MESSAGE_SUBST", BtShellWord)
                   1248:        reg.pkg("META_PACKAGE", BtYes)
                   1249:        reg.syslist("MISSING_FEATURES", BtIdentifier)
                   1250:        reg.pkglist("MYSQL_VERSIONS_ACCEPTED", mysqlVersions)
                   1251:        reg.usr("MYSQL_VERSION_DEFAULT", BtVersion)
                   1252:        reg.sys("NATIVE_CC", BtShellCommand) // See mk/platform/tools.NetBSD.mk (and some others).
                   1253:        reg.sys("NM", BtShellCommand)
                   1254:        reg.sys("NONBINMODE", BtFileMode)
                   1255:        reg.pkglistrat("NOT_FOR_COMPILER", compilers)
                   1256:        reg.pkglistrat("NOT_FOR_BULK_PLATFORM", BtMachinePlatformPattern)
                   1257:        reg.pkglistrat("NOT_FOR_PLATFORM", BtMachinePlatformPattern)
                   1258:        reg.pkgrat("NOT_FOR_UNPRIVILEGED", BtYesNo)
1.73    ! rillig   1259:        reg.pkglistrat("NOT_PAX_ASLR_SAFE", BtPathPattern)
        !          1260:        reg.pkglistrat("NOT_PAX_MPROTECT_SAFE", BtPathPattern)
1.67      rillig   1261:        reg.pkg("NO_BIN_ON_CDROM", BtRestricted)
                   1262:        reg.pkg("NO_BIN_ON_FTP", BtRestricted)
                   1263:        reg.pkgload("NO_BUILD", BtYes)
                   1264:        reg.pkg("NO_CHECKSUM", BtYes)
                   1265:        reg.pkg("NO_CONFIGURE", BtYes)
                   1266:        reg.pkg("NO_EXPORT_CPP", BtYes)
                   1267:        reg.pkg("NO_EXTRACT", BtYes)
                   1268:        reg.pkg("NO_INSTALL_MANPAGES", BtYes) // only has an effect for Imake packages.
                   1269:        reg.pkg("NO_PKGTOOLS_REQD_CHECK", BtYes)
                   1270:        reg.pkg("NO_SRC_ON_CDROM", BtRestricted)
                   1271:        reg.pkg("NO_SRC_ON_FTP", BtRestricted)
                   1272:        reg.sysload("OBJECT_FMT", enum("COFF ECOFF ELF SOM XCOFF Mach-O PE a.out"))
                   1273:        reg.pkglistrat("ONLY_FOR_COMPILER", compilers)
                   1274:        reg.pkglistrat("ONLY_FOR_PLATFORM", BtMachinePlatformPattern)
                   1275:        reg.pkgrat("ONLY_FOR_UNPRIVILEGED", BtYesNo)
                   1276:        reg.sysload("OPSYS", reg.enumFromFiles("mk/platform", `(.*)\.mk$`, "$1",
1.59      rillig   1277:                "Cygwin DragonFly FreeBSD Linux NetBSD SunOS"))
1.67      rillig   1278:        reg.pkglistbl3("OPSYSVARS", BtVariableName)
                   1279:        reg.pkg("OSVERSION_SPECIFIC", BtYes)
                   1280:        reg.sysload("OS_VERSION", BtVersion)
                   1281:        reg.sysload("OSX_VERSION", BtVersion) // See mk/platform/Darwin.mk.
                   1282:        reg.pkg("OVERRIDE_DIRDEPTH*", BtInteger)
                   1283:        reg.pkg("OVERRIDE_GNU_CONFIG_SCRIPTS", BtYes)
                   1284:        reg.pkg("OWNER", BtMailAddress)
1.73    ! rillig   1285:        reg.pkglist("OWN_DIRS", BtPathPattern)
1.67      rillig   1286:        reg.pkglist("OWN_DIRS_PERMS", BtPerms)
                   1287:        reg.sys("PAMBASE", BtPathname)
                   1288:        reg.usr("PAM_DEFAULT", enum("linux-pam openpam solaris-pam"))
                   1289:        reg.pkgload("PATCHDIR", BtRelativePkgPath)
1.73    ! rillig   1290:        reg.pkglist("PATCHFILES", BtFilename)
1.67      rillig   1291:        reg.pkglist("PATCH_ARGS", BtShellWord)
                   1292:        reg.pkglist("PATCH_DIST_ARGS", BtShellWord)
                   1293:        reg.pkg("PATCH_DIST_CAT", BtShellCommand)
                   1294:        reg.pkg("PATCH_DIST_STRIP*", BtShellWord)
                   1295:        reg.pkglist("PATCH_SITES", BtFetchURL)
                   1296:        reg.pkg("PATCH_STRIP", BtShellWord)
                   1297:        reg.sysload("PATH", BtPathlist)   // From the PATH environment variable.
                   1298:        reg.sys("PAXCTL", BtShellCommand) // See mk/pax.mk.
                   1299:        reg.pkglist("PERL5_PACKLIST", BtPerl5Packlist)
                   1300:        reg.pkg("PERL5_PACKLIST_DIR", BtPathname)
                   1301:        reg.pkglistrat("PERL5_REQD", BtVersion)
                   1302:        reg.sysbl3("PERL5_INSTALLARCHLIB", BtPathname) // See lang/perl5/vars.mk
                   1303:        reg.sysbl3("PERL5_INSTALLSCRIPT", BtPathname)
                   1304:        reg.sysbl3("PERL5_INSTALLVENDORBIN", BtPathname)
                   1305:        reg.sysbl3("PERL5_INSTALLVENDORSCRIPT", BtPathname)
                   1306:        reg.sysbl3("PERL5_INSTALLVENDORARCH", BtPathname)
                   1307:        reg.sysbl3("PERL5_INSTALLVENDORLIB", BtPathname)
                   1308:        reg.sysbl3("PERL5_INSTALLVENDORMAN1DIR", BtPathname)
                   1309:        reg.sysbl3("PERL5_INSTALLVENDORMAN3DIR", BtPathname)
                   1310:        reg.sysbl3("PERL5_SUB_INSTALLARCHLIB", BtPrefixPathname) // See lang/perl5/vars.mk
                   1311:        reg.sysbl3("PERL5_SUB_INSTALLSCRIPT", BtPrefixPathname)
                   1312:        reg.sysbl3("PERL5_SUB_INSTALLVENDORBIN", BtPrefixPathname)
                   1313:        reg.sysbl3("PERL5_SUB_INSTALLVENDORSCRIPT", BtPrefixPathname)
                   1314:        reg.sysbl3("PERL5_SUB_INSTALLVENDORARCH", BtPrefixPathname)
                   1315:        reg.sysbl3("PERL5_SUB_INSTALLVENDORLIB", BtPrefixPathname)
                   1316:        reg.sysbl3("PERL5_SUB_INSTALLVENDORMAN1DIR", BtPrefixPathname)
                   1317:        reg.sysbl3("PERL5_SUB_INSTALLVENDORMAN3DIR", BtPrefixPathname)
                   1318:        reg.pkg("PERL5_USE_PACKLIST", BtYesNo)
                   1319:        reg.sys("PGSQL_PREFIX", BtPathname)
                   1320:        reg.acllist("PGSQL_VERSIONS_ACCEPTED", pgsqlVersions,
1.62      rillig   1321:                PackageSettable|NeedsRationale,
1.57      rillig   1322:                // The "set" is necessary for databases/postgresql-postgis2.
                   1323:                "Makefile, Makefile.*, *.mk: default, set, append, use")
1.67      rillig   1324:        reg.usr("PGSQL_VERSION_DEFAULT", BtVersion)
                   1325:        reg.sys("PG_LIB_EXT", enum("dylib so"))
                   1326:        reg.sys("PGSQL_TYPE",
                   1327:                reg.enumFrom(src, "mk/pgsql.buildlink3.mk", "postgresql11-client", "PGSQL_TYPE"))
                   1328:        reg.sys("PGPKGSRCDIR", BtPathname)
                   1329:        reg.sys("PHASE_MSG", BtShellCommand)
                   1330:        reg.usr("PHP_VERSION_REQD", BtVersion)
                   1331:        reg.acl("PHP_PKG_PREFIX",
                   1332:                reg.enumFromDirs(src, "lang", `^php(\d+)$`, "php$1", "php56 php71 php72 php73"),
1.59      rillig   1333:                SystemProvided,
1.57      rillig   1334:                "special:phpversion.mk: set",
                   1335:                "*: use, use-loadtime")
1.67      rillig   1336:        reg.sys("PKGBASE", BtIdentifier)
1.57      rillig   1337:        // Despite its name, this is actually a list of filenames.
1.67      rillig   1338:        reg.acllist("PKGCONFIG_FILE.*", BtPathname,
1.59      rillig   1339:                PackageSettable,
1.57      rillig   1340:                "builtin.mk: set, append",
                   1341:                "special:pkgconfig-builtin.mk: use-loadtime")
1.73    ! rillig   1342:        reg.pkglist("PKGCONFIG_OVERRIDE", BtPathPattern)
1.67      rillig   1343:        reg.pkg("PKGCONFIG_OVERRIDE_STAGE", BtStage)
                   1344:        reg.pkg("PKGDIR", BtRelativePkgDir)
                   1345:        reg.sys("PKGDIRMODE", BtFileMode)
                   1346:        reg.sys("PKGLOCALEDIR", BtPathname)
1.73    ! rillig   1347:        reg.pkg("PKGNAME", BtPkgname)
        !          1348:        reg.sys("PKGNAME_NOREV", BtPkgname)
        !          1349:        reg.sysload("PKGPATH", BtPkgpath)
1.67      rillig   1350:        reg.sys("PKGREPOSITORY", BtUnknown)
1.57      rillig   1351:        // This variable is special in that it really only makes sense to
                   1352:        // be set in a package Makefile.
1.73    ! rillig   1353:        // See VartypeCheck.Pkgrevision for details.
        !          1354:        reg.acl("PKGREVISION", BtPkgrevision,
1.59      rillig   1355:                PackageSettable,
1.57      rillig   1356:                "Makefile: set")
1.67      rillig   1357:        reg.sys("PKGSRCDIR", BtPathname)
1.57      rillig   1358:        // This definition is only valid in the top-level Makefile,
                   1359:        // not in category or package Makefiles.
1.67      rillig   1360:        reg.acl("PKGSRCTOP", BtYes,
1.59      rillig   1361:                PackageSettable,
1.57      rillig   1362:                "Makefile: set")
1.67      rillig   1363:        reg.sys("PKGSRC_SETENV", BtShellCommand)
                   1364:        reg.syslist("PKGTOOLS_ENV", BtShellWord)
                   1365:        reg.sys("PKGVERSION", BtVersion)
                   1366:        reg.sys("PKGVERSION_NOREV", BtVersion) // Without the nb* part.
1.73    ! rillig   1367:        reg.sys("PKGWILDCARD", BtFilePattern)
1.67      rillig   1368:        reg.sysload("PKG_ADMIN", BtShellCommand)
                   1369:        reg.sys("PKG_APACHE", enum("apache24"))
                   1370:        reg.pkglistrat("PKG_APACHE_ACCEPTED", enum("apache24"))
                   1371:        reg.usr("PKG_APACHE_DEFAULT", enum("apache24"))
                   1372:        reg.sysloadlist("PKG_BUILD_OPTIONS.*", BtOption)
                   1373:        reg.usr("PKG_CONFIG", BtYes)
1.1       rillig   1374:        // ^^ No, this is not the popular command from GNOME, but the setting
                   1375:        // whether the pkgsrc user wants configuration files automatically
                   1376:        // installed or not.
1.67      rillig   1377:        reg.sys("PKG_CREATE", BtShellCommand)
                   1378:        reg.sys("PKG_DBDIR", BtPathname)
                   1379:        reg.cmdline("PKG_DEBUG_LEVEL", BtInteger)
                   1380:        reg.usrlist("PKG_DEFAULT_OPTIONS", BtOption)
                   1381:        reg.sys("PKG_DELETE", BtShellCommand)
                   1382:        reg.pkglist("PKG_DESTDIR_SUPPORT", enum("destdir user-destdir"))
                   1383:        reg.pkglist("PKG_FAIL_REASON", BtShellWord)
                   1384:        reg.sysload("PKG_FORMAT", BtIdentifier)
                   1385:        reg.pkg("PKG_GECOS.*", BtMessage)
                   1386:        reg.pkg("PKG_GID.*", BtInteger)
                   1387:        reg.pkglist("PKG_GROUPS", BtShellWord)
                   1388:        reg.pkglist("PKG_GROUPS_VARS", BtVariableName)
                   1389:        reg.pkg("PKG_HOME.*", BtPathname)
1.57      rillig   1390:        // PKG_HACKS is used to record the applied hacks in the binary package.
                   1391:        // Since only the hacks.mk can define hacks, appending to it only makes
                   1392:        // sense there.
                   1393:        //
1.60      rillig   1394:        // TODO: Is it possible that a package includes the hacks.mk file from
                   1395:        //  one of its dependencies?
1.67      rillig   1396:        reg.acllist("PKG_HACKS", BtIdentifier,
1.59      rillig   1397:                PackageSettable,
1.60      rillig   1398:                "*: none")
1.67      rillig   1399:        reg.sys("PKG_INFO", BtShellCommand)
                   1400:        reg.sys("PKG_JAVA_HOME", BtPathname)
                   1401:        reg.sys("PKG_JVM", jvms)
                   1402:        reg.pkglistrat("PKG_JVMS_ACCEPTED", jvms)
                   1403:        reg.pkg("PKG_LIBTOOL", BtPathname)
1.57      rillig   1404:
                   1405:        // begin PKG_OPTIONS section
                   1406:        //
                   1407:        // TODO: force the pkgsrc packages to only define options in the
                   1408:        //  options.mk file. Most packages already do this, but some still
                   1409:        //  define them in the Makefile or Makefile.common.
1.67      rillig   1410:        reg.sysloadlist("PKG_OPTIONS", BtOption)
                   1411:        reg.usrlist("PKG_OPTIONS.*", BtOption)
                   1412:        opt := reg.pkg
                   1413:        optlist := reg.pkglist
1.57      rillig   1414:        optlist("PKG_LEGACY_OPTIONS", BtOption)
                   1415:        optlist("PKG_OPTIONS_DEPRECATED_WARNINGS", BtShellWord)
                   1416:        optlist("PKG_OPTIONS_GROUP.*", BtOption)
                   1417:        optlist("PKG_OPTIONS_LEGACY_OPTS", BtUnknown)
                   1418:        optlist("PKG_OPTIONS_LEGACY_VARS", BtUnknown)
                   1419:        optlist("PKG_OPTIONS_NONEMPTY_SETS", BtIdentifier)
                   1420:        optlist("PKG_OPTIONS_OPTIONAL_GROUPS", BtIdentifier)
                   1421:        optlist("PKG_OPTIONS_REQUIRED_GROUPS", BtIdentifier)
                   1422:        optlist("PKG_OPTIONS_SET.*", BtOption)
                   1423:        opt("PKG_OPTIONS_VAR", BtPkgOptionsVar)
1.67      rillig   1424:        reg.pkglist("PKG_SKIP_REASON", BtShellWord)
1.57      rillig   1425:        optlist("PKG_SUGGESTED_OPTIONS", BtOption)
                   1426:        optlist("PKG_SUGGESTED_OPTIONS.*", BtOption)
                   1427:        optlist("PKG_SUPPORTED_OPTIONS", BtOption)
                   1428:        // end PKG_OPTIONS section
                   1429:
1.67      rillig   1430:        reg.pkg("PKG_PRESERVE", BtYes)
                   1431:        reg.pkg("PKG_SHELL", BtPathname)
                   1432:        reg.pkg("PKG_SHELL.*", BtPathname)
                   1433:        reg.sys("PKG_SHLIBTOOL", BtPathname)
1.57      rillig   1434:        // The special exception for buildlink3.mk is only here because
                   1435:        // of textproc/xmlcatmgr.
1.67      rillig   1436:        reg.acl("PKG_SYSCONFDIR*", BtPathname,
1.59      rillig   1437:                PackageSettable,
1.57      rillig   1438:                "Makefile: set, use, use-loadtime",
                   1439:                "buildlink3.mk, builtin.mk: use-loadtime",
1.47      rillig   1440:                "Makefile.*, *.mk: default, set, use, use-loadtime")
1.67      rillig   1441:        reg.pkglist("PKG_SYSCONFDIR_PERMS", BtPerms)
                   1442:        reg.sys("PKG_SYSCONFBASEDIR", BtPathname)
                   1443:        reg.pkg("PKG_SYSCONFSUBDIR", BtPathname)
                   1444:        reg.pkg("PKG_SYSCONFVAR", BtIdentifier)
                   1445:        reg.pkg("PKG_UID", BtInteger)
                   1446:        reg.pkglist("PKG_USERS", BtShellWord)
                   1447:        reg.pkglist("PKG_USERS_VARS", BtVariableName)
                   1448:        reg.pkg("PKG_USE_KERBEROS", BtYes)
                   1449:        reg.pkgload("PLIST.*", BtYes)
                   1450:        reg.pkglist("PLIST_VARS", BtIdentifier)
                   1451:        reg.pkglist("PLIST_SRC", BtRelativePkgPath)
                   1452:        reg.pkglist("PLIST_SUBST", BtShellWord)
                   1453:        reg.pkg("PLIST_TYPE", enum("dynamic static"))
                   1454:        reg.pkglistbl3("PREPEND_PATH", BtPathname)
1.57      rillig   1455:
1.67      rillig   1456:        reg.acl("PREFIX", BtPathname,
1.59      rillig   1457:                UserSettable,
1.57      rillig   1458:                "*: use")
1.73    ! rillig   1459:        // BtPathname instead of BtPkgpath since the original package doesn't exist anymore.
        !          1460:        // It would be more precise to check for a Pkgpath that doesn't exist anymore.
1.67      rillig   1461:        reg.pkg("PREV_PKGPATH", BtPathname)
                   1462:        reg.acl("PRINT_PLIST_AWK", BtAwkCommand,
1.59      rillig   1463:                PackageSettable,
1.57      rillig   1464:                "*: append")
1.67      rillig   1465:        reg.pkglist("PRIVILEGED_STAGES", enum("build install package clean"))
                   1466:        reg.pkgbl3("PTHREAD_AUTO_VARS", BtYesNo)
                   1467:        reg.syslist("PTHREAD_CFLAGS", BtCFlag)
                   1468:        reg.syslist("PTHREAD_LDFLAGS", BtLdFlag)
                   1469:        reg.syslist("PTHREAD_LIBS", BtLdFlag)
                   1470:        reg.pkglistbl3("PTHREAD_OPTS", enum("native optional require"))
                   1471:        reg.sysload("PTHREAD_TYPE", BtIdentifier) // Or "native" or "none".
                   1472:        reg.pkg("PY_PATCHPLIST", BtYes)
                   1473:        reg.acl("PYPKGPREFIX",
                   1474:                reg.enumFromDirs(src, "lang", `^python(\d+)$`, "py$1", "py27 py36"),
1.59      rillig   1475:                SystemProvided,
1.57      rillig   1476:                "special:pyversion.mk: set",
                   1477:                "*: use, use-loadtime")
                   1478:        // See lang/python/pyversion.mk
1.67      rillig   1479:        reg.pkg("PYTHON_FOR_BUILD_ONLY", enum("yes no test tool YES"))
                   1480:        reg.pkglistrat("PYTHON_VERSIONS_ACCEPTED", BtVersion)
                   1481:        reg.pkglistrat("PYTHON_VERSIONS_INCOMPATIBLE", BtVersion)
                   1482:        reg.usr("PYTHON_VERSION_DEFAULT", BtVersion)
                   1483:        reg.usr("PYTHON_VERSION_REQD", BtVersion)
                   1484:        reg.pkglist("PYTHON_VERSIONED_DEPENDENCIES", BtPythonDependency)
                   1485:        reg.sys("RANLIB", BtShellCommand)
1.73    ! rillig   1486:        reg.pkglist("RCD_SCRIPTS", BtFilename)
1.57      rillig   1487:        // TODO: Is the definition in www/squid3/Makefile detected as being redundant?
                   1488:        //  No, but it could if the RedundancyScope were able to resolve ${FILESDIR}
                   1489:        //  to "files".
1.67      rillig   1490:        reg.pkg("RCD_SCRIPT_SRC.*", BtPathname)
                   1491:        reg.pkg("RCD_SCRIPT_WRK.*", BtPathname)
                   1492:        reg.usr("REAL_ROOT_USER", BtUserGroupName)
                   1493:        reg.usr("REAL_ROOT_GROUP", BtUserGroupName)
1.57      rillig   1494:
                   1495:        // Example:
                   1496:        //  REPLACE.sys-AWK.old=    .*awk
                   1497:        //  REPLACE.sys-AWK.new=    ${AWK}
                   1498:        // BtUnknown since one of them is a regular expression and the other
                   1499:        // is a plain string.
1.67      rillig   1500:        reg.pkg("REPLACE.*", BtUnknown)
1.57      rillig   1501:
1.73    ! rillig   1502:        reg.pkglist("REPLACE_AWK", BtPathPattern)
        !          1503:        reg.pkglist("REPLACE_BASH", BtPathPattern)
        !          1504:        reg.pkglist("REPLACE_CSH", BtPathPattern)
        !          1505:        reg.pkglist("REPLACE_FILES.*", BtPathPattern)
1.67      rillig   1506:        reg.pkglist("REPLACE_INTERPRETER", BtIdentifier)
1.73    ! rillig   1507:        reg.pkglist("REPLACE_KSH", BtPathPattern)
        !          1508:        reg.pkglist("REPLACE_LOCALEDIR_PATTERNS", BtFilePattern)
        !          1509:        reg.pkglist("REPLACE_LUA", BtPathPattern)
        !          1510:        reg.pkglist("REPLACE_PERL", BtPathPattern)
        !          1511:        reg.pkglist("REPLACE_PYTHON", BtPathPattern)
        !          1512:        reg.pkglist("REPLACE_SH", BtPathPattern)
1.67      rillig   1513:        reg.pkglist("REQD_DIRS", BtPathname)
                   1514:        reg.pkglist("REQD_DIRS_PERMS", BtPerms)
                   1515:        reg.pkglist("REQD_FILES", BtPathname)
                   1516:        reg.pkg("REQD_FILES_MODE", enum("0644 0640 0600 0400"))
                   1517:        reg.pkglist("REQD_FILES_PERMS", BtPerms)
                   1518:        reg.pkg("RESTRICTED", BtMessage)
                   1519:        reg.usr("ROOT_USER", BtUserGroupName)
                   1520:        reg.usr("ROOT_GROUP", BtUserGroupName)
1.73    ! rillig   1521:        reg.pkglist("RPMIGNOREPATH", BtPathPattern)
1.67      rillig   1522:        reg.acl("RUBY_BASE",
                   1523:                reg.enumFromDirs(src, "lang", `^ruby(\d+)$`, "ruby$1", "ruby22 ruby23 ruby24 ruby25"),
1.59      rillig   1524:                SystemProvided,
1.57      rillig   1525:                "special:rubyversion.mk: set",
                   1526:                "*: use, use-loadtime")
1.67      rillig   1527:        reg.usr("RUBY_VERSION_REQD", BtVersion)
                   1528:        reg.acl("RUBY_PKGPREFIX",
                   1529:                reg.enumFromDirs(src, "lang", `^ruby(\d+)$`, "ruby$1", "ruby22 ruby23 ruby24 ruby25"),
1.59      rillig   1530:                SystemProvided,
1.57      rillig   1531:                "special:rubyversion.mk: default, set, use",
                   1532:                "*: use, use-loadtime")
1.67      rillig   1533:        reg.sys("RUN", BtShellCommand)
                   1534:        reg.sys("RUN_LDCONFIG", BtYesNo)
1.70      rillig   1535:        reg.pkg("R_PKGNAME", BtRPkgName)
                   1536:        reg.pkg("R_PKGVER", BtRPkgVer)
1.67      rillig   1537:        reg.pkglist("SCRIPTS_ENV", BtShellWord)
                   1538:        reg.usrlist("SETGID_GAMES_PERMS", BtPerms)
                   1539:        reg.usrlist("SETUID_ROOT_PERMS", BtPerms)
                   1540:        reg.pkg("SET_LIBDIR", BtYes)
                   1541:        reg.sys("SHAREGRP", BtUserGroupName)
                   1542:        reg.sys("SHAREMODE", BtFileMode)
                   1543:        reg.sys("SHAREOWN", BtUserGroupName)
                   1544:        reg.sys("SHCOMMENT", BtShellCommand)
                   1545:        reg.sys("SHLIBTOOL", BtShellCommand)
1.73    ! rillig   1546:        reg.pkglist("SHLIBTOOL_OVERRIDE", BtPathPattern)
1.67      rillig   1547:        reg.sysload("SHLIB_TYPE",
1.57      rillig   1548:                enum("COFF ECOFF ELF SOM XCOFF Mach-O PE PEwin a.out aixlib dylib none"))
1.67      rillig   1549:        reg.pkglist("SITES.*", BtFetchURL)
                   1550:        reg.usr("SMF_PREFIS", BtPathname)
                   1551:        reg.pkg("SMF_SRCDIR", BtPathname)
1.73    ! rillig   1552:        reg.pkg("SMF_NAME", BtFilename)
1.67      rillig   1553:        reg.pkg("SMF_MANIFEST", BtPathname)
                   1554:        reg.pkglist("SMF_INSTANCES", BtIdentifier)
1.73    ! rillig   1555:        reg.pkglist("SMF_METHODS", BtFilename)
1.67      rillig   1556:        reg.pkg("SMF_METHOD_SRC.*", BtPathname)
                   1557:        reg.pkg("SMF_METHOD_SHELL", BtShellCommand)
                   1558:        reg.pkglist("SPECIAL_PERMS", BtPerms)
                   1559:        reg.sys("STEP_MSG", BtShellCommand)
                   1560:        reg.sys("STRIP", BtShellCommand) // see mk/tools/strip.mk
1.59      rillig   1561:
1.57      rillig   1562:        // Only valid in the top-level and the category Makefiles.
1.73    ! rillig   1563:        reg.acllist("SUBDIR", BtFilename,
1.59      rillig   1564:                PackageSettable,
1.57      rillig   1565:                "Makefile: append")
                   1566:
1.67      rillig   1567:        reg.pkglistbl3("SUBST_CLASSES", BtIdentifier)
                   1568:        reg.pkglistbl3("SUBST_CLASSES.*", BtIdentifier) // OPSYS-specific
1.73    ! rillig   1569:        reg.pkglistbl3("SUBST_FILES.*", BtPathPattern)
1.67      rillig   1570:        reg.pkgbl3("SUBST_FILTER_CMD.*", BtShellCommand)
                   1571:        reg.pkgbl3("SUBST_MESSAGE.*", BtMessage)
                   1572:        reg.pkgappendbl3("SUBST_SED.*", BtSedCommands)
                   1573:        reg.pkgbl3("SUBST_STAGE.*", BtStage)
                   1574:        reg.pkglistbl3("SUBST_VARS.*", BtVariableName)
                   1575:
                   1576:        reg.pkglist("SUPERSEDES", BtDependency)
                   1577:        reg.pkglist("TEST_DEPENDS", BtDependencyWithPath)
                   1578:        reg.pkglist("TEST_DIRS", BtWrksrcSubdirectory)
                   1579:        reg.pkglist("TEST_ENV", BtShellWord)
                   1580:        reg.pkglist("TEST_TARGET", BtIdentifier)
                   1581:        reg.pkglistrat("TEXINFO_REQD", BtVersion)
                   1582:        reg.pkglistbl3("TOOL_DEPENDS", BtDependencyWithPath)
1.73    ! rillig   1583:        reg.syslist("TOOLS_ALIASES", BtFilename)
1.67      rillig   1584:        reg.syslist("TOOLS_BROKEN", BtTool)
                   1585:        reg.sys("TOOLS_CMD.*", BtPathname)
                   1586:        reg.pkglist("TOOLS_CREATE", BtTool)
                   1587:        reg.pkglist("TOOLS_DEPENDS.*", BtDependencyWithPath)
                   1588:        reg.syslist("TOOLS_GNU_MISSING", BtTool)
                   1589:        reg.syslist("TOOLS_NOOP", BtTool)
                   1590:        reg.sys("TOOLS_PATH.*", BtPathname)
                   1591:        reg.sysload("TOOLS_PLATFORM.*", BtShellCommand)
1.72      rillig   1592:        reg.sysload("TOOLS_SHELL", BtShellCommand)
1.67      rillig   1593:        reg.syslist("TOUCH_FLAGS", BtShellWord)
                   1594:        reg.pkglist("UAC_REQD_EXECS", BtPrefixPathname)
                   1595:        reg.pkglistbl3("UNLIMIT_RESOURCES",
1.57      rillig   1596:                enum("cputime datasize memorysize stacksize"))
1.67      rillig   1597:        reg.usr("UNPRIVILEGED_USER", BtUserGroupName)
                   1598:        reg.usr("UNPRIVILEGED_GROUP", BtUserGroupName)
1.73    ! rillig   1599:        reg.pkglist("UNWRAP_FILES", BtPathPattern)
1.67      rillig   1600:        reg.usrlist("UPDATE_TARGET", BtIdentifier)
                   1601:        reg.pkg("USERGROUP_PHASE", enum("configure build pre-install"))
1.73    ! rillig   1602:        reg.usrlist("USER_ADDITIONAL_PKGS", BtPkgpath)
1.67      rillig   1603:        reg.pkg("USE_BSD_MAKEFILE", BtYes)
1.59      rillig   1604:
1.57      rillig   1605:        // USE_BUILTIN.* is usually set by the builtin.mk file, after checking
                   1606:        // whether the package is available in the base system. To override
                   1607:        // this check, a package may set this variable before including the
                   1608:        // corresponding buildlink3.mk file.
1.67      rillig   1609:        reg.acl("USE_BUILTIN.*", BtYesNoIndirectly,
1.59      rillig   1610:                PackageSettable,
1.57      rillig   1611:                "Makefile, Makefile.*, *.mk: set, use, use-loadtime")
1.59      rillig   1612:
1.67      rillig   1613:        reg.pkg("USE_CMAKE", BtYes)
                   1614:        reg.usr("USE_DESTDIR", BtYes)
                   1615:        reg.pkglist("USE_FEATURES", BtIdentifier)
                   1616:        reg.pkg("USE_GAMESGROUP", BtYesNo)
                   1617:        reg.pkg("USE_GCC_RUNTIME", BtYesNo)
                   1618:        reg.pkg("USE_GNU_CONFIGURE_HOST", BtYesNo)
                   1619:        reg.pkgload("USE_GNU_ICONV", BtYes)
                   1620:        reg.pkg("USE_IMAKE", BtYes)
                   1621:        reg.pkg("USE_JAVA", enum("run yes build"))
                   1622:        reg.pkg("USE_JAVA2", enum("YES yes no 1.4 1.5 6 7 8"))
                   1623:        reg.pkglist("USE_LANGUAGES", reg.compilerLanguages(src))
                   1624:        reg.pkg("USE_LIBTOOL", BtYes)
                   1625:        reg.pkg("USE_MAKEINFO", BtYes)
                   1626:        reg.pkg("USE_MSGFMT_PLURALS", BtYes)
                   1627:        reg.pkg("USE_NCURSES", BtYes)
                   1628:        reg.pkg("USE_OLD_DES_API", BtYesNo)
                   1629:        reg.pkg("USE_PKGINSTALL", BtYes)
                   1630:        reg.pkg("USE_PKGLOCALEDIR", BtYesNo)
                   1631:        reg.usr("USE_PKGSRC_GCC", BtYes)
1.37      rillig   1632:
1.57      rillig   1633:        // USE_TOOLS is not similar to any predefined permissions set.
                   1634:        //
                   1635:        // It may be appended to in buildlink3 files to make tools available
                   1636:        // at runtime. Making tools available at load time would only work
                   1637:        // before bsd.prefs.mk has been included for the first time, and that
                   1638:        // cannot be guaranteed.
                   1639:        //
                   1640:        // There are a few builtin.mk files that check whether some tool is
                   1641:        // already contained in USE_TOOLS. For them, use-loadtime is allowed.
                   1642:        //
                   1643:        // All other files may also use = instead of +=. Cases where the tools
                   1644:        // list is accidentally overwritten are detected by the redundancy check.
                   1645:        //
                   1646:        // The use-loadtime is only for devel/ncurses/Makefile.common, which
                   1647:        // removes tbl from USE_TOOLS.
1.67      rillig   1648:        reg.acllist("USE_TOOLS", BtTool,
1.59      rillig   1649:                PackageSettable,
1.57      rillig   1650:                "special:Makefile.common: set, append, use, use-loadtime",
                   1651:                "buildlink3.mk: append",
                   1652:                "builtin.mk: append, use-loadtime",
                   1653:                "*: set, append, use")
1.67      rillig   1654:        reg.acllist("USE_TOOLS.*", BtTool, // OPSYS-specific
1.59      rillig   1655:                PackageSettable,
1.57      rillig   1656:                "buildlink3.mk, builtin.mk: append",
                   1657:                "*: set, append, use")
                   1658:
1.67      rillig   1659:        reg.pkg("USE_X11", BtYes)
                   1660:        reg.syslist("WARNINGS", BtShellWord)
                   1661:        reg.sys("WARNING_MSG", BtShellCommand)
                   1662:        reg.sys("WARNING_CAT", BtShellCommand)
                   1663:        reg.sysload("WRAPPER_DIR", BtPathname)
                   1664:        reg.pkglistbl3("WRAPPER_REORDER_CMDS", BtWrapperReorder)
                   1665:        reg.pkg("WRAPPER_SHELL", BtShellCommand)
                   1666:        reg.pkglist("WRAPPER_TRANSFORM_CMDS", BtWrapperTransform)
                   1667:        reg.sys("WRKDIR", BtPathname)
                   1668:        reg.pkg("WRKSRC", BtWrkdirSubdirectory)
                   1669:        reg.pkglist("X11_LDFLAGS", BtLdFlag)
                   1670:        reg.sys("X11_PKGSRCDIR.*", BtPathname)
                   1671:        reg.pkglist("XMKMF_FLAGS", BtShellWord)
                   1672:        reg.pkglist("_WRAP_EXTRA_ARGS.*", BtShellWord)
                   1673:
                   1674:        reg.infralist("_VARGROUPS", BtIdentifier)
1.68      rillig   1675:        reg.infralist("_USER_VARS.*", BtVariableName)
                   1676:        reg.infralist("_PKG_VARS.*", BtVariableName)
                   1677:        reg.infralist("_SYS_VARS.*", BtVariableName)
                   1678:        reg.infralist("_DEF_VARS.*", BtVariableName)
                   1679:        reg.infralist("_USE_VARS.*", BtVariableName)
1.72      rillig   1680:        reg.infralist("_IGN_VARS.*", BtVariableNamePattern)
1.68      rillig   1681:        reg.infralist("_SORTED_VARS.*", BtVariableNamePattern)
                   1682:        reg.infralist("_LISTED_VARS.*", BtVariableNamePattern)
1.1       rillig   1683: }
                   1684:
1.14      rillig   1685: func enum(values string) *BasicType {
1.45      rillig   1686:        valueMap := make(map[string]bool)
1.53      rillig   1687:        for _, value := range strings.Fields(values) {
1.45      rillig   1688:                valueMap[value] = true
1.1       rillig   1689:        }
                   1690:        name := "enum: " + values + " " // See IsEnum
1.52      rillig   1691:        basicType := BasicType{name, nil}
1.45      rillig   1692:        basicType.checker = func(check *VartypeCheck) {
1.52      rillig   1693:                check.Enum(valueMap, &basicType)
1.45      rillig   1694:        }
1.52      rillig   1695:        return &basicType
1.1       rillig   1696: }
                   1697:
1.57      rillig   1698: func (reg *VarTypeRegistry) parseACLEntries(varname string, aclEntries ...string) []ACLEntry {
                   1699:
1.68      rillig   1700:        assert(len(aclEntries) > 0)
1.57      rillig   1701:
                   1702:        // TODO: Use separate rules for infrastructure files.
                   1703:        //  These rules would have the "infra:" prefix
                   1704:        //  that works similar to the already existing prefix "special:".
                   1705:        //  The "infra:" prefix applies to both mk/* and wip/mk/* files, and globs
                   1706:        //  without that prefix only apply to all files outside the infrastructure.
1.54      rillig   1707:
1.36      rillig   1708:        var result []ACLEntry
1.11      rillig   1709:        prevperms := "(first)"
1.57      rillig   1710:        for _, arg := range aclEntries {
                   1711:                fields := strings.Split(arg, ": ")
1.67      rillig   1712:                assertf(len(fields) == 2, "ACL entry %q must have exactly 1 colon.", arg)
1.57      rillig   1713:                globs, perms := fields[0], fields[1]
1.56      rillig   1714:
1.67      rillig   1715:                assertf(perms != prevperms, "Repeated permissions %q for %q.", perms, varname)
1.11      rillig   1716:                prevperms = perms
1.46      rillig   1717:
1.57      rillig   1718:                permissions := reg.parsePermissions(varname, globs, perms)
1.46      rillig   1719:
1.4       rillig   1720:                for _, glob := range strings.Split(globs, ", ") {
                   1721:                        switch glob {
                   1722:                        case "*",
1.57      rillig   1723:                                "Makefile", "Makefile.*",
1.60      rillig   1724:                                "buildlink3.mk", "builtin.mk", "options.mk", "*.mk":
1.4       rillig   1725:                                break
                   1726:                        default:
1.55      rillig   1727:                                withoutSpecial := strings.TrimPrefix(glob, "special:")
                   1728:                                if withoutSpecial == glob {
1.67      rillig   1729:                                        assertf(false, "Invalid ACL glob %q for %q.", glob, varname)
1.55      rillig   1730:                                } else {
                   1731:                                        glob = withoutSpecial
                   1732:                                }
1.4       rillig   1733:                        }
                   1734:                        for _, prev := range result {
1.68      rillig   1735:                                matched := prev.matcher.matches(glob)
1.67      rillig   1736:                                assertf(!matched, "Unreachable ACL pattern %q for %q.", glob, varname)
1.4       rillig   1737:                        }
1.66      rillig   1738:                        result = append(result, NewACLEntry(glob, permissions))
1.4       rillig   1739:                }
1.1       rillig   1740:        }
1.57      rillig   1741:
1.1       rillig   1742:        return result
                   1743: }
1.57      rillig   1744:
                   1745: func (reg *VarTypeRegistry) parsePermissions(varname, globs, perms string) ACLPermissions {
                   1746:        if perms == "none" {
                   1747:                return aclpNone
                   1748:        }
                   1749:
                   1750:        splitPerms := strings.Split(perms, ", ")
                   1751:        var permissions ACLPermissions
                   1752:
                   1753:        remove := func(name string, perm ACLPermissions) {
                   1754:                if len(splitPerms) > 0 && splitPerms[0] == name {
                   1755:                        permissions |= perm
                   1756:                        splitPerms = splitPerms[1:]
                   1757:                }
                   1758:        }
                   1759:
                   1760:        // The order of the assignment permissions is in perceived
                   1761:        // chronological order. First the default assignment, which
                   1762:        // can later be overridden by an unconditional assignment,
                   1763:        // and that can be appended later to add more values.
                   1764:        remove("default", aclpSetDefault)
                   1765:        remove("set", aclpSet)
                   1766:        remove("append", aclpAppend)
                   1767:
                   1768:        // When using a variable, "use" comes first because it feels
                   1769:        // more general. Most variables that can be used at load time
                   1770:        // can also be used at run time.
                   1771:        //
                   1772:        // Using a variable at load time is a special access that
                   1773:        // applies to fewer variables. Therefore it comes last.
                   1774:        remove("use", aclpUse)
                   1775:        remove("use-loadtime", aclpUseLoadtime)
                   1776:
                   1777:        if len(splitPerms) > 0 {
1.67      rillig   1778:                assertf(
1.57      rillig   1779:                        false,
                   1780:                        "Invalid ACL permission %q for %q in %q. "+
                   1781:                                "Remaining parts are %q. "+
                   1782:                                "Valid permissions are default, set, append, "+
                   1783:                                "use, use-loadtime (in this order), or none.",
                   1784:                        perms, varname, globs, strings.Join(splitPerms, ", "))
                   1785:        }
                   1786:        return permissions
                   1787: }

CVSweb <webmaster@jp.NetBSD.org>