Changeset cb12e48 in rtems-source-builder


Ignore:
Timestamp:
Apr 9, 2013, 3:51:43 AM (6 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, 4.9, master
Children:
7e48e8f
Parents:
530a938
Message:

Refactor defaults, macros and options.

To support building snapshots and pre-release source the defaults
has been refactored. The defaults have been moved to a stand alone
file and a macros.py module added. This modile abstracts the
old default dictionary turning it into a class. The macros
class can load macros from a file therefore the defaults have
been moved to a stand alone file.

The use of defaults has been removed from the project. The only
case where it is used in the options where the defaults are read
from a file. Macros are used everywhere now.

The defaults.py has been moved to the option.py and the separate
options and defaults values has been moved to a new pattern. When
constructing an object that needs macros and options if the macros
passed in is None the defaults from the options are used. This makes
it clear when the defaults are being used or when a modified set of
macros is being used.

The macros class support maps. The default is 'global' and where all
the defaults reside and where configuratiion file changes end up.
Maps allow macros to be read from a file and override the values
being maintained in the 'global' map. Reading a macro first checks
the map and if not present checks the 'global' map.

The addition of maps to the macros provides the base to support
snapshots and pre-release testing with standard configurations.
This functionality needs to be added. It works by letting to
specify a snapshot with:

source0: none, override, 'my-dist.tar.bz2'

and it will be used rather the value from the standard configuration.
With a build set you need to also specify the package these macros
are for. The maps provide this.

Location:
source-builder
Files:
2 added
8 edited
1 moved

Legend:

Unmodified
Added
Removed
  • source-builder/sb-defaults

    r530a938 rcb12e48  
    2323sys.path.insert(0, base + '/sb')
    2424try:
    25     import defaults
    26     defaults.run(sys.argv)
     25    import options
     26    options.run(sys.argv)
    2727except ImportError:
    2828    print >> sys.stderr, "Incorrect Defaults installation"
  • source-builder/sb/build.py

    r530a938 rcb12e48  
    3535    import check
    3636    import config
    37     import defaults
    3837    import error
    3938    import execute
    4039    import log
     40    import options
    4141    import path
    4242    import version
     
    100100    """Build a package given a config file."""
    101101
    102     def __init__(self, name, create_tar_files, _defaults, opts):
     102    def __init__(self, name, create_tar_files, opts, macros = None):
    103103        self.opts = opts
     104        if macros is None:
     105            self.macros = opts.defaults
     106        else:
     107            self.macros = macros
    104108        self.create_tar_files = create_tar_files
    105109        _notice(opts, 'config: ' + name)
    106         self.config = config.file(name, _defaults = _defaults, opts = opts)
     110        self.config = config.file(name, opts, self.macros)
    107111        self.script = script(quiet = opts.quiet(), trace = opts.trace())
    108112
     
    482486        return package.name()
    483487
    484 def get_configs(opts, _defaults):
     488def get_configs(opts):
    485489
    486490    def _scan(_path, ext):
     
    495499
    496500    configs = { 'paths': [], 'files': [] }
    497     for cp in opts.expand('%{_configdir}', _defaults).split(':'):
     501    for cp in opts.defaults.expand('%{_configdir}').split(':'):
    498502        hcp = path.host(path.abspath(cp))
    499503        configs['paths'] += [hcp]
     
    517521    try:
    518522        optargs = { '--list-configs': 'List available configurations' }
    519         opts, _defaults = defaults.load(args, optargs)
     523        opts = options.load(args, optargs)
    520524        log.default = log.log(opts.logfiles())
    521525        _notice(opts, 'RTEMS Source Builder, Package Builder v%s' % (version.str()))
    522         if not check.host_setup(opts, _defaults):
     526        if not check.host_setup(opts):
    523527            if not opts.force():
    524528                raise error.general('host build environment is not set up' +
     
    526530            _notice(opts, 'warning: forcing build with known host setup problems')
    527531        if opts.get_arg('--list-configs'):
    528             configs = get_configs(opts, _defaults)
     532            configs = get_configs(opts)
    529533            for p in configs['paths']:
    530534                print 'Examining: %s' % (os.path.relpath(p))
     
    534538        else:
    535539            for config_file in opts.config_files():
    536                 b = build(config_file, True, _defaults = _defaults, opts = opts)
     540                b = build(config_file, True, opts)
    537541                b.make()
    538542                del b
  • source-builder/sb/check.py

    r530a938 rcb12e48  
    2424import os
    2525
    26 import defaults
    2726import error
    2827import execute
    2928import log
     29import options
    3030import path
    3131import version
     
    101101    return False
    102102
    103 def host_setup(_opts, _defaults):
     103def host_setup(opts):
    104104    """ Basic sanity check. All executables and directories must exist."""
    105105
     
    111111    sane = True
    112112
    113     for d in sorted(_defaults.iterkeys()):
     113    for d in opts.defaults.keys():
    114114        try:
    115             (test, constraint, value) = _defaults[d]
     115            (test, constraint, value) = opts.defaults.get(d)
    116116        except:
    117             raise error.general('invalid default: %s [%r]' % (d, _defaults[d]))
     117            raise error.general('invalid default: %s [%r]' % (d, opts.defaults.get(d)))
    118118        if test != 'none':
    119             value = _opts.expand(value, _defaults)
     119            value = opts.defaults.expand(value)
    120120            if test not in checks:
    121                 raise error.general('invalid check test: %s [%r]' % (test, _defaults[d]))
    122             ok = checks[test](_opts, d, value, constraint)
    123             if _opts.trace():
     121                raise error.general('invalid check test: %s [%r]' % (test, opts.defaults.get(d)))
     122            ok = checks[test](opts, d, value, constraint)
     123            if opts.trace():
    124124                if ok:
    125125                    tag = ' '
    126126                else:
    127127                    tag = '*'
    128                 _notice(_opts, '%c %15s: %r -> "%s"' % (tag, d, _defaults[d], value))
     128                _notice(opts, '%c %15s: %r -> "%s"' % (tag, d, opts.defaults.get(d), value))
    129129            if sane and not ok:
    130130                sane = False
     
    136136    import sys
    137137    try:
    138         _opts, _defaults = defaults.load(args = sys.argv)
     138        _opts = options.load(args = sys.argv)
    139139        _notice(_opts, 'RTEMS Source Builder - Check, v%s' % (version.str()))
    140         if host_setup(_opts, _defaults):
     140        if host_setup(_opts):
    141141            print 'Environment is ok'
    142142        else:
  • source-builder/sb/config.py

    r530a938 rcb12e48  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2012 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2013 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    3232
    3333try:
    34     import defaults
    3534    import error
    3635    import execute
    3736    import log
     37    import options
    3838    import path
    3939except KeyboardInterrupt:
     
    208208                re.compile('%patch[0-9]*') ]
    209209
    210     def __init__(self, name, _defaults, opts):
     210    def __init__(self, name, opts, macros = None):
    211211        self.opts = opts
     212        if macros is None:
     213            self.macros = opts.defaults
     214        else:
     215            self.macros = macros
    212216        if self.opts.trace():
    213217            print 'config: %s' % (name)
     
    217221        self.tags = re.compile(r':+')
    218222        self.sf = re.compile(r'%\([^\)]+\)')
    219         self.default_defines = {}
    220         for d in _defaults:
    221             self.default_defines[self._label(d)] = _defaults[d][2]
    222223        for arg in self.opts.args:
    223224            if arg.startswith('--with-') or arg.startswith('--without-'):
    224225                label = arg[2:].lower().replace('-', '_')
    225                 self.default_defines[self._label(label)] = label
     226                self.macros.define(label)
    226227        self._includes = []
    227228        self.load_depth = 0
     
    242243            '\nlines parsed: %d' % (self.lc) + \
    243244            '\nname: ' + self.name + \
    244             '\ndefines:\n' + _dict(self.defines)
     245            '\nmacros:\n' + str(self.macros)
    245246        for _package in self._packages:
    246247            s += str(self._packages[_package])
     
    267268
    268269    def _label(self, name):
     270        if name.startswith('%{') and name[-1] is '}':
     271            return name
    269272        return '%{' + name.lower() + '}'
    270273
     
    384387                    #
    385388                    n = self._label('with_' + m[7:-1].strip())
    386                     if n in self.defines:
     389                    if n in self.macros:
    387390                        s = s.replace(m, '1')
    388391                    else:
     
    402405                elif m.startswith('%{defined'):
    403406                    n = self._label(m[9:-1].strip())
    404                     if n in self.defines:
     407                    if n in self.macros:
    405408                        s = s.replace(m, '1')
    406409                    else:
     
    425428                        if m.startswith('%{?'):
    426429                            istrue = False
    427                             if mn in self.defines:
     430                            if mn in self.macros:
    428431                                # If defined and 0 then it is false.
    429                                 istrue = _check_bool(self.defines[mn])
     432                                istrue = _check_bool(self.macros[mn])
    430433                                if istrue is None:
    431434                                    istrue = True
     
    438441                        else:
    439442                            isfalse = True
    440                             if mn in self.defines:
    441                                 istrue = _check_bool(self.defines[mn])
     443                            if mn in self.macros:
     444                                istrue = _check_bool(self.macros[mn])
    442445                                if istrue is None or istrue == True:
    443446                                    isfalse = False
     
    449452                                mn = '%{nil}'
    450453                if mn:
    451                     if mn.lower() in self.defines:
    452                         s = s.replace(m, self.defines[mn.lower()])
     454                    if mn.lower() in self.macros:
     455                        s = s.replace(m, self.macros[mn.lower()])
    453456                        expanded = True
    454457                    elif show_warning:
     
    462465            d = self._label(ls[1])
    463466            if self.disable_macro_reassign:
    464                 if (d not in self.defines) or \
    465                         (d in self.defines and len(self.defines[d]) == 0):
     467                if (d not in self.macros) or \
     468                        (d in self.macros and len(self.macros[d]) == 0):
    466469                    if len(ls) == 2:
    467                         self.defines[d] = '1'
    468                     else:
    469                         self.defines[d] = ' '.join([f.strip() for f in ls[2:]])
     470                        self.macros[d] = '1'
     471                    else:
     472                        self.macros[d] = ' '.join([f.strip() for f in ls[2:]])
    470473                else:
    471474                    self._warning("macro '%s' already defined" % (d))
    472475            else:
    473476                if len(ls) == 2:
    474                     self.defines[d] = '1'
     477                    self.macros[d] = '1'
    475478                else:
    476                     self.defines[d] = ' '.join([f.strip() for f in ls[2:]])
     479                    self.macros[d] = ' '.join([f.strip() for f in ls[2:]])
    477480
    478481    def _undefine(self, config, ls):
     
    481484        else:
    482485            mn = self._label(ls[1])
    483             if mn in self.defines:
    484                 del self.defines[mn]
     486            if mn in self.macros:
     487                del self.macros[mn]
    485488            else:
    486489                self._warning("macro '%s' not defined" % (mn))
     
    704707                        # even a host specific default.
    705708                        #
    706                         if self._label('with_' + ls[1]) not in self.defines:
     709                        if self._label('with_' + ls[1]) not in self.macros:
    707710                            self._define(config, (ls[0], 'without_' + ls[1]))
    708711                elif ls[0] == '%bcond_without':
    709712                    if isvalid:
    710                         if self._label('without_' + ls[1]) not in self.defines:
     713                        if self._label('without_' + ls[1]) not in self.macros:
    711714                            self._define(config, (ls[0], 'with_' + ls[1]))
    712715                else:
     
    756759            self.lc = 0
    757760            self.name = name
    758             self.defines = copy.deepcopy(self.default_defines)
    759761            self.conditionals = {}
    760762            self._packages = {}
     
    899901
    900902    def defined(self, name):
    901         return name.lower() in self.defines
     903        return self.macros.has_key(name)
    902904
    903905    def define(self, name):
    904         if name.lower() in self.defines:
    905             d = self.defines[name.lower()]
     906        if name in self.macros:
     907            d = self.macros[name]
    906908        else:
    907909            n = self._label(name)
    908             if n in self.defines:
    909                 d = self.defines[n]
     910            if n in self.macros:
     911                d = self.macros[n]
    910912            else:
    911913                raise error.general('%d: macro "%s" not found' % (self.lc, name))
     
    923925        return self._expand(line)
    924926
    925     def default(self, name):
     927    def macro(self, name):
    926928        if name.lower() in self.defines:
    927929            return self.defines[name.lower()]
     
    948950    import sys
    949951    try:
    950         opts, _defaults = defaults.load(sys.argv)
     952        #
     953        # Run where defaults.mc is located
     954        #
     955        opts = options.load(sys.argv, defaults = 'defaults.mc')
    951956        if opts.trace():
    952957            print 'config: count %d' % (len(opts.config_files()))
    953958        for config_file in opts.config_files():
    954             s = file(config_file, _defaults = _defaults, opts = opts)
     959            s = file(config_file, opts)
    955960            print s
    956961            del s
  • source-builder/sb/darwin.py

    r530a938 rcb12e48  
    2323#
    2424
    25 import pprint
    2625import os
    2726
     
    5756
    5857if __name__ == '__main__':
     58    import pprint
    5959    pprint.pprint(load())
  • source-builder/sb/git.py

    r530a938 rcb12e48  
    2424import os
    2525
    26 import defaults
    2726import error
    2827import execute
     28import options
    2929import path
    3030
     
    4343        return exit_code, output
    4444
    45     def __init__(self, _path, _opts, _defaults):
     45    def __init__(self, _path, opts, macros = None):
    4646        self.path = _path
    47         self.opts = _opts
    48         self.default = _defaults
    49         self.git = _opts.expand('%{__git}', _defaults)
     47        self.opts = opts
     48        if macros is None:
     49            self.macros = opts.defaults
     50        else:
     51            self.macros = macros
     52        self.git = self.macros.expand('%{__git}')
    5053
    5154    def git_version(self):
     
    121124if __name__ == '__main__':
    122125    import sys
    123     _opts, _defaults = defaults.load(sys.argv)
    124     g = repo('.', _opts, _defaults)
     126    opts = options.load(sys.argv)
     127    g = repo('.', opts)
    125128    print g.git_version()
    126129    print g.valid()
  • source-builder/sb/options.py

    r530a938 rcb12e48  
    11#
    22# RTEMS Tools Project (http://www.rtems.org/)
    3 # Copyright 2010-2012 Chris Johns (chrisj@rtems.org)
     3# Copyright 2010-2013 Chris Johns (chrisj@rtems.org)
    44# All rights reserved.
    55#
     
    2626import re
    2727import os
     28import string
    2829
    2930import error
    3031import execute
    3132import git
     33import macros
    3234import path
    3335import sys
     
    3537basepath = 'sb'
    3638
    37 #
    38 # All paths in defaults must be Unix format. Do not store any Windows format
    39 # paths in the defaults.
    40 #
    41 # Every entry must describe the type of checking a host must pass.
    42 #
    43 
    44 defaults = {
    45 # Nothing
    46 'nil':                 ('none', 'none', ''),
    47 
    48 # Set to invalid values.
    49 '_bset':               ('none',    'none', ''),
    50 'name':                ('none',    'none', ''),
    51 'version':             ('none',    'none', ''),
    52 'release':             ('none',    'none', ''),
    53 
    54 # GNU triples needed to build packages
    55 '_host':               ('triplet', 'required', ''),
    56 '_build':              ('triplet', 'required', '%{_host}'),
    57 '_target':             ('none',    'optional', ''),
    58 
    59 # Paths
    60 '_host_platform':      ('none',    'none',     '%{_host_cpu}-%{_host_vendor}-%{_host_os}%{?_gnu}'),
    61 '_arch':               ('none',    'none',     '%{_host_arch}'),
    62 '_sbdir':              ('none',    'none',     ''),
    63 '_topdir':             ('dir',     'required',  path.shell(os.getcwd())),
    64 '_configdir':          ('dir',     'optional', '%{_topdir}/config:%{_sbdir}/config'),
    65 '_tardir':             ('dir',     'optional', '%{_topdir}/tar'),
    66 '_sourcedir':          ('dir',     'optional', '%{_topdir}/sources'),
    67 '_patchdir':           ('dir',     'optional', '%{_topdir}/patches:%{_sbdir}/patches'),
    68 '_builddir':           ('dir',     'optional', '%{_topdir}/build/%{name}-%{version}-%{release}'),
    69 '_buildcxcdir':        ('dir',     'optional', '%{_topdir}/build/%{name}-%{version}-%{release}-cxc'),
    70 '_docdir':             ('dir',     'none',     '%{_defaultdocdir}'),
    71 '_tmppath':            ('dir',     'none',     '%{_topdir}/build/tmp'),
    72 '_tmproot':            ('dir',     'none',     '%{_tmppath}/source-build-%(%{__id_u} -n)/%{_bset}'),
    73 '_tmpcxcroot':         ('dir',     'none',     '%{_tmppath}/source-build-%(%{__id_u} -n)-cxc/%{_bset}'),
    74 'buildroot':           ('dir',     'none',     '%{_tmppath}/%{name}-root-%(%{__id_u} -n)'),
    75 'buildcxcroot':        ('dir',     'none',     '%{_tmppath}/%{name}-root-%(%{__id_u} -n)-cxc'),
    76 '_datadir':            ('dir',     'none',     '%{_prefix}/share'),
    77 '_defaultdocdir':      ('dir',     'none',     '%{_prefix}/share/doc'),
    78 '_exeext':             ('none',    'none',     ''),
    79 '_exec_prefix':        ('dir',     'none',     '%{_prefix}'),
    80 '_bindir':             ('dir',     'none',     '%{_exec_prefix}/bin'),
    81 '_sbindir':            ('dir',     'none',     '%{_exec_prefix}/sbin'),
    82 '_libexecdir':         ('dir',     'none',     '%{_exec_prefix}/libexec'),
    83 '_datarootdir':        ('dir',     'none',     '%{_prefix}/share'),
    84 '_datadir':            ('dir',     'none',     '%{_datarootdir}'),
    85 '_sysconfdir':         ('dir',     'none',     '%{_prefix}/etc'),
    86 '_sharedstatedir':     ('dir',     'none',     '%{_prefix}/com'),
    87 '_localstatedir':      ('dir',     'none',     '%{prefix}/var'),
    88 '_includedir':         ('dir',     'none',     '%{_prefix}/include'),
    89 '_lib':                ('dir',     'none',     'lib'),
    90 '_libdir':             ('dir',     'none',     '%{_exec_prefix}/%{_lib}'),
    91 '_libexecdir':         ('dir',     'none',     '%{_exec_prefix}/libexec'),
    92 '_mandir':             ('dir',     'none',     '%{_datarootdir}/man'),
    93 '_infodir':            ('dir',     'none',     '%{_datarootdir}/info'),
    94 '_localedir':          ('dir',     'none',     '%{_datarootdir}/locale'),
    95 '_localedir':          ('dir',     'none',     '%{_datadir}/locale'),
    96 '_localstatedir':      ('dir',     'none',     '%{_prefix}/var'),
    97 '_prefix':             ('dir',     'none',     '%{_usr}'),
    98 '_usr':                ('dir',     'none',     '/usr/local'),
    99 '_usrsrc':             ('dir',     'none',     '%{_usr}/src'),
    100 '_var':                ('dir',     'none',     '/usr/local/var'),
    101 '_varrun':             ('dir',     'none',     '%{_var}/run'),
    102 
    103 # Defaults, override in platform specific modules.
    104 '___setup_shell':      ('exe',     'required', '/bin/sh'),
    105 '__aclocal':           ('exe',     'optional', 'aclocal'),
    106 '__ar':                ('exe',     'required', 'ar'),
    107 '__arch_install_post': ('exe',     'none',     '%{nil}'),
    108 '__as':                ('exe',     'required', 'as'),
    109 '__autoconf':          ('exe',     'required', 'autoconf'),
    110 '__autoheader':        ('exe',     'required', 'autoheader'),
    111 '__automake':          ('exe',     'required', 'automake'),
    112 '__awk':               ('exe',     'required', 'awk'),
    113 '__bash':              ('exe',     'optional', '/bin/bash'),
    114 '__bison':             ('exe',     'required', '/usr/bin/bison'),
    115 '__bzip2':             ('exe',     'required', '/usr/bin/bzip2'),
    116 '__cat':               ('exe',     'required', '/bin/cat'),
    117 '__cc':                ('exe',     'required', '/usr/bin/gcc'),
    118 '__chgrp':             ('exe',     'required', '/usr/bin/chgrp'),
    119 '__chmod':             ('exe',     'required', '/bin/chmod'),
    120 '__chown':             ('exe',     'required', '/usr/sbin/chown'),
    121 '__cp':                ('exe',     'required', '/bin/cp'),
    122 '__cpp':               ('exe',     'none',     '%{__cc} -E'),
    123 '__cxx':               ('exe',     'required', '/usr/bin/g++'),
    124 '__flex':              ('exe',     'required', '/usr/bin/flex'),
    125 '__git':               ('exe',     'required', '/usr/bin/git'),
    126 '__grep':              ('exe',     'required', '/usr/bin/grep'),
    127 '__gzip':              ('exe',     'required', '/usr/bin/gzip'),
    128 '__id':                ('exe',     'required', '/usr/bin/id'),
    129 '__id_u':              ('exe',     'none',     '%{__id} -u'),
    130 '__install':           ('exe',     'required', '/usr/bin/install'),
    131 '__install_info':      ('exe',     'optional', '/usr/bin/install-info'),
    132 '__ld':                ('exe',     'required', '/usr/bin/ld'),
    133 '__ldconfig':          ('exe',     'required', '/sbin/ldconfig'),
    134 '__ln_s':              ('exe',     'none',     'ln -s'),
    135 '__make':              ('exe',     'required', 'make'),
    136 '__makeinfo':          ('exe',     'required', '/usr/bin/makeinfo'),
    137 '__mkdir':             ('exe',     'required', '/bin/mkdir'),
    138 '__mkdir_p':           ('exe',     'none',     '/bin/mkdir -p'),
    139 '__mv':                ('exe',     'required', '/bin/mv'),
    140 '__nm':                ('exe',     'required', '/usr/bin/nm'),
    141 '__objcopy':           ('exe',     'optional', '/usr/bin/objcopy'),
    142 '__objdump':           ('exe',     'optional', '/usr/bin/objdump'),
    143 '__patch_bin':         ('exe',     'required', '/usr/bin/patch'),
    144 '__patch_opts':        ('none',    'none',     '%{nil}'),
    145 '__patch':             ('exe',     'none',     '%{__patch_bin} %{__patch_opts}'),
    146 '__perl':              ('exe',     'optional', 'perl'),
    147 '__ranlib':            ('exe',     'required', 'ranlib'),
    148 '__rm':                ('exe',     'required', '/bin/rm'),
    149 '__rmfile':            ('exe',     'none',     '%{__rm} -f'),
    150 '__rmdir':             ('exe',     'none',     '%{__rm} -rf'),
    151 '__sed':               ('exe',     'required', '/usr/bin/sed'),
    152 '__setup_post':        ('exe',     'none',     '%{__chmod} -R a+rX,g-w,o-w .'),
    153 '__sh':                ('exe',     'required', '/bin/sh'),
    154 '__tar':               ('exe',     'required', '/usr/bin/tar'),
    155 '__tar_extract':       ('exe',     'none',     '%{__tar} -xvvf'),
    156 '__touch':             ('exe',     'required', '/usr/bin/touch'),
    157 '__unzip':             ('exe',     'required', '/usr/bin/unzip'),
    158 '__xz':                ('exe',     'required', '/usr/bin/xz'),
    159 
    160 # Shell Build Settings.
    161 '___build_args': ('none', 'none', '-e'),
    162 '___build_cmd':  ('none', 'none', '%{?_sudo:%{_sudo} }%{?_remsh:%{_remsh} %{_remhost} }%{?_remsudo:%{_remsudo} }%{?_remchroot:%{_remchroot} %{_remroot} }%{___build_shell} %{___build_args}'),
    163 '___build_post': ('none', 'none', 'exit 0'),
    164 
    165 # Prebuild set up script.
    166 '___build_pre': ('none', 'none', '''# ___build_pre in as set up in defaults.py
    167 # Save the original path away.
    168 export SB_ORIG_PATH=${PATH}
    169 # Directories
    170 %{?_prefix:SB_PREFIX="%{_prefix}"}
    171 %{?_prefix:SB_PREFIX_CLEAN=$(echo "%{_prefix}" | %{__sed} -e \'s/^\///\')}
    172 SB_SOURCE_DIR="%{_sourcedir}"
    173 SB_BUILD_DIR="%{_builddir}"
    174 SB_OPT_FLAGS="%{?_tmproot:-I%{_tmproot}/${SB_PREFIX_CLEAN}/include -L%{_tmproot}/${SB_PREFIX_CLEAN}/lib} %{optflags}"
    175 SB_ARCH="%{_arch}"
    176 SB_OS="%{_os}"
    177 export SB_SOURCE_DIR SB_BUILD_DIR SB_OPT_FLAGS SB_ARCH SB_OS
    178 # Documentation
    179 SB_DOC_DIR="%{_docdir}"
    180 export SB_DOC_DIR
    181 # Packages
    182 SB_PACKAGE_NAME="%{name}"
    183 SB_PACKAGE_VERSION="%{version}"
    184 SB_PACKAGE_RELEASE="%{release}"
    185 export SB_PACKAGE_NAME SB_PACKAGE_VERSION SB_PACKAGE_RELEASE
    186 # Build directories
    187 export SB_PREFIX
    188 %{?_builddir:SB_BUILD_DIR="%{_builddir}"}
    189 %{?buildroot:SB_BUILD_ROOT="%{buildroot}"}
    190 %{?buildroot:%{?_prefix:SB_BUILD_ROOT_BINDIR="%{buildroot}/${SB_PREFIX_CLEAN}/bin"}}
    191 export SB_BUILD_ROOT SB_BUILD_DIR SB_BUILD_ROOT_BINDIR
    192 %{?_buildcxcdir:SB_BUILD_CXC_DIR="%{_buildcxcdir}"}
    193 %{?buildcxcroot:SB_BUILD_CXC_ROOT="%{buildcxcroot}"}
    194 %{?buildcxcroot:%{?_prefix:SB_BUILD_CXC_ROOT_BINDIR="%{buildcxcroot}/${SB_PREFIX_CLEAN}/bin"}}
    195 export SB_BUILD_CXC_ROOT SB_BUILD_CXC_DIR SB_BUILD_CXC_ROOT_BINDIR
    196 %{?_tmproot:SB_TMPROOT="%{_tmproot}"}
    197 %{?_tmproot:%{?_prefix:SB_TMPPREFIX="%{_tmproot}/${SB_PREFIX_CLEAN}"}}
    198 %{?_tmproot:%{?_prefix:SB_TMPBINDIR="%{_tmproot}/${SB_PREFIX_CLEAN}/bin"}}
    199 export SB_TMPROOT SB_TMPPREFIX SB_TMPBINDIR
    200 %{?_tmpcxcroot:SB_TMPCXCROOT="%{_tmproot}"}
    201 %{?_tmpcxcroot:%{?_prefix:SB_TMPCXCPREFIX="%{_tmpcxcroot}/${SB_PREFIX_CLEAN}"}}
    202 %{?_tmpcxcroot:%{?_prefix:SB_TMPCXCBINDIR="%{_tmpcxcroot}/${SB_PREFIX_CLEAN}/bin"}}
    203 export SB_TMPCXCROOT SB_TMPCXCPREFIX SB_TMPCXCBINDIR
    204 # The compiler flags
    205 %{?_targetcflags:CFLAGS_FOR_TARGET="%{_targetcflags}"}
    206 %{?_targetcxxflags:CXXFLAGS_FOR_TARGET="%{_targetcxxflags}"}
    207 export CFLAGS_FOR_TARGET
    208 export CXXFLAGS_FOR_TARGET
    209 # Set up the path. Put the CXC path first.
    210 if test -n "${SB_TMPBINDIR}" ; then
    211  PATH="${SB_TMPBINDIR}:$PATH"
    212 fi
    213 if test -n "${SB_TMPCXCBINDIR}" ; then
    214  PATH="${SB_TMPCXCBINDIR}:$PATH"
    215 fi
    216 export PATH
    217 # Default environment set up.
    218 LANG=C
    219 export LANG
    220 unset DISPLAY || :
    221 umask 022
    222 cd "%{_builddir}"'''),
    223 '___build_shell': ('none', 'none', '%{?_buildshell:%{_buildshell}}%{!?_buildshell:/bin/sh}'),
    224 '___build_template': ('none', 'none', '''#!%{___build_shell}
    225 %{___build_pre}
    226 %{nil}'''),
    227 
    228 # Configure command
    229 'configure': ('none', 'none', '''
    230 CFLAGS="${CFLAGS:-%optflags}" ; export CFLAGS ;
    231 CXXFLAGS="${CXXFLAGS:-%optflags}" ; export CXXFLAGS ;
    232 FFLAGS="${FFLAGS:-%optflags}" ; export FFLAGS ;
    233 ./configure --build=%{_build} --host=%{_host} \
    234       --target=%{_target_platform} \
    235       --program-prefix=%{?_program_prefix} \
    236       --prefix=%{_prefix} \
    237       --exec-prefix=%{_exec_prefix} \
    238       --bindir=%{_bindir} \
    239       --sbindir=%{_sbindir} \
    240       --sysconfdir=%{_sysconfdir} \
    241       --datadir=%{_datadir} \
    242       --includedir=%{_includedir} \
    243       --libdir=%{_libdir} \
    244       --libexecdir=%{_libexecdir} \
    245       --localstatedir=%{_localstatedir} \
    246       --sharedstatedir=%{_sharedstatedir} \
    247       --mandir=%{_mandir} \
    248       --infodir=%{_infodir}''')
    249 }
    250 
    25139class command_line:
    25240    """Process the command line in a common way for all Tool Builder commands."""
    25341
    254     def __init__(self, argv, optargs):
     42    def __init__(self, argv, optargs, _defaults, command_path):
    25543        self._long_opts = {
    25644            # key                 macro              handler            param  defs    init
     
    28169            }
    28270
    283         self.command_path = path.dirname(argv[0])
    284         if len(self.command_path) == 0:
    285             self.command_path = '.'
     71        self.command_path = command_path
    28672        self.command_name = path.basename(argv[0])
    28773        self.argv = argv
    28874        self.args = argv[1:]
    28975        self.optargs = optargs
    290         self.defaults = {}
    291         self.defaults['_sbdir'] = ('dir', 'required', path.shell(self.command_path))
     76        self.defaults = _defaults
    29277        self.opts = { 'params' : [] }
    29378        for lo in self._long_opts:
     
    29580            if self._long_opts[lo][4]:
    29681                self.defaults[self._long_opts[lo][0]] = ('none', 'none', self._long_opts[lo][3])
    297         self._process()
    29882
    29983    def __str__(self):
     
    316100            raise error.general('option requires a value: %s' % (opt))
    317101        self.opts[opt[2:]] = value
    318         self.defaults[macro] = ('none', 'none', value)
     102        self.defaults[macro] = value
    319103
    320104    def _lo_path(self, opt, macro, value):
     
    323107        value = path.shell(value)
    324108        self.opts[opt[2:]] = value
    325         self.defaults[macro] = ('none', 'none', value)
     109        self.defaults[macro] = value
    326110
    327111    def _lo_jobs(self, opt, macro, value):
     
    345129        if not ok:
    346130            raise error.general('invalid jobs option: %s' % (value))
    347         self.defaults[macro] = ('none', 'none', value)
     131        self.defaults[macro] = value
    348132        self.opts[opt[2:]] = value
    349133
     
    352136            raise error.general('option does not take a value: %s' % (opt))
    353137        self.opts[opt[2:]] = '1'
    354         self.defaults[macro] = ('none', 'none', '1')
     138        self.defaults[macro] = '1'
    355139
    356140    def _lo_triplets(self, opt, macro, value):
     
    384168        if len(value):
    385169            _os_value = value
    386         self.defaults[_cpu] = ('none', 'none', _arch_value)
    387         self.defaults[_arch] = ('none', 'none', _arch_value)
    388         self.defaults[_vendor] = ('none', 'none', _vendor_value)
    389         self.defaults[_os] = ('none', 'none', _os_value)
     170        self.defaults[_cpu]    = _arch_value
     171        self.defaults[_arch]   = _arch_value
     172        self.defaults[_vendor] = _vendor_value
     173        self.defaults[_os]     = _os_value
    390174
    391175    def _lo_help(self, opt, macro, value):
    392176        self.help()
    393177
    394     def _help(self):
     178    def help(self):
    395179        print '%s: [options] [args]' % (self.command_name)
    396180        print 'RTEMS Source Builder, an RTEMS Tools Project (c) 2012-2013 Chris Johns'
     
    425209        raise error.exit()
    426210
    427     def _process(self):
     211    def process(self):
    428212        arg = 0
    429213        while arg < len(self.args):
    430214            a = self.args[arg]
    431215            if a == '-?':
    432                 self._help()
     216                self.help()
    433217            elif a.startswith('--'):
    434218                los = a.split('=')
     
    451235            arg += 1
    452236
    453     def _post_process(self, _defaults):
    454         if _defaults['_host'][2] == _defaults['nil'][2]:
     237    def post_process(self):
     238        if self.defaults['_host'] == self.defaults['nil']:
    455239            raise error.general('host not set')
    456         if '_ncpus' not in _defaults:
     240        if '_ncpus' not in self.defaults:
    457241            raise error.general('host number of CPUs not set')
    458         ncpus = self.jobs(_defaults['_ncpus'][2])
     242        ncpus = self.jobs(self.defaults['_ncpus'])
    459243        if ncpus > 1:
    460             _defaults['_smp_mflags'] = ('none', 'none', '-j %d' % (ncpus))
     244            self.defaults['_smp_mflags'] = '-j %d' % (ncpus)
    461245        else:
    462             _defaults['_smp_mflags'] = ('none', 'none', _defaults['nil'][2])
    463         return _defaults
    464 
    465     def define(self, _defaults, key, value = '1'):
    466         _defaults[key] = ('none', 'none', value)
    467 
    468     def undefine(self, _defaults, key):
    469         if key in _defaults:
    470             del _defaults[key]
    471 
    472     def expand(self, s, _defaults):
    473         """Simple basic expander of config file macros."""
    474         mf = re.compile(r'%{[^}]+}')
    475         expanded = True
    476         while expanded:
    477             expanded = False
    478             for m in mf.findall(s):
    479                 name = m[2:-1]
    480                 if name in _defaults:
    481                     s = s.replace(m, _defaults[name][2])
    482                     expanded = True
    483                 else:
    484                     raise error.general('cannot expand default macro: %s in "%s"' %
    485                                         (m, s))
    486         return s
     246            self.defaults['_smp_mflags'] = self.defaults['nil']
    487247
    488248    def command(self):
     
    574334                configbase = configbase + '.cfg'
    575335            if len(configdir) == 0:
    576                 configdir = self.expand(self.defaults['_configdir'][2], self.defaults)
     336                configdir = self.macros.expand(self.defaults['_configdir'])
    577337            configs = []
    578338            for cp in configdir.split(':'):
     
    591351
    592352    def logfiles(self):
    593         if 'log' in self.opts:
     353        if 'log' in self.opts and self.opts['log'] is not None:
    594354            return self.opts['log'].split(',')
    595355        return ['stdout']
     
    600360        return None
    601361
    602 def load(args, optargs = None):
     362def load(args, optargs = None, defaults = '%{_sbdir}/defaults.mc'):
    603363    """
    604364    Copy the defaults, get the host specific values and merge them overriding
     
    607367    command line.
    608368    """
    609     import copy
    610     d = copy.copy(defaults)
     369
     370    #
     371    # The path to this command.
     372    #
     373    command_path = path.dirname(args[0])
     374    if len(command_path) == 0:
     375        command_path = '.'
     376
     377    #
     378    # The command line contains the base defaults object all build objects copy
     379    # and modify by loading a configuration.
     380    #
     381    o = command_line(args,
     382                     optargs,
     383                     macros.macros(name = defaults,
     384                                   sbdir = command_path),
     385                     command_path)
     386
    611387    overrides = None
    612388    if os.name == 'nt':
     
    635411        raise error.general('no hosts defaults found; please add')
    636412    for k in overrides:
    637         d[k] = overrides[k]
    638     o = command_line(args, optargs)
    639     for k in o.defaults:
    640         d[k] = o.defaults[k]
    641     d = o._post_process(d)
    642     repo = git.repo(o.expand('%{_sbdir}', d), o, d)
     413        o.defaults[k] = overrides[k]
     414
     415    o.process()
     416    o.post_process()
     417
     418    repo = git.repo(o.defaults.expand('%{_sbdir}'), o)
    643419    if repo.valid():
    644420        repo_valid = '1'
     
    653429        repo_clean = '%{nil}'
    654430        repo_id = 'no-repo'
    655     o.define(d, '_sbgit_valid', repo_valid)
    656     o.define(d, '_sbgit_head', repo_head)
    657     o.define(d, '_sbgit_clean', str(repo_clean))
    658     o.define(d, '_sbgit_id', repo_id)
    659     return o, d
     431    o.defaults['_sbgit_valid'] = repo_valid
     432    o.defaults['_sbgit_head']  = repo_head
     433    o.defaults['_sbgit_clean'] = str(repo_clean)
     434    o.defaults['_sbgit_id']    = repo_id
     435    return o
    660436
    661437def run(args):
    662438    try:
    663         _opts, _defaults = load(args = args)
     439        _opts = load(args = args)
    664440        print 'Options:'
    665441        print _opts
    666442        print 'Defaults:'
    667         for k in sorted(_defaults.keys()):
    668             d = _defaults[k]
    669             print '%-20s: %-8s %-10s' % (k, d[0], d[1]),
    670             indent = False
    671             if len(d[2]) == 0:
    672                 print
    673             text_len = 80
    674             for l in d[2].split('\n'):
    675                 while len(l):
    676                     if indent:
    677                         print '%20s  %8s %10s' % (' ', ' ', ' '),
    678                     print l[0:text_len],
    679                     l = l[text_len:]
    680                     if len(l):
    681                         print ' \\',
    682                     print
    683                     indent = True
     443        print _opts.defaults
    684444    except error.general, gerr:
    685445        print gerr
  • source-builder/sb/reports.py

    r530a938 rcb12e48  
    3232    import check
    3333    import config
    34     import defaults
    3534    import error
    3635    import git
    3736    import log
     37    import options
    3838    import path
    3939    import setbuilder
     
    5757    line_len = 78
    5858
    59     def __init__(self, format, _configs, _defaults, opts):
     59    def __init__(self, format, _configs, opts, macros = None):
    6060        self.format = format
    6161        self.configs = _configs
    62         self.defaults = _defaults
    6362        self.opts = opts
     63        if macros is None:
     64            self.macros = opts.defaults
     65        else:
     66            self.macros = macros
    6467        self.bset_nesting = 0
    6568        self.configs_active = False
     
    6871
    6972    def _sbpath(self, *args):
    70         p = self.opts.expand('%{_sbdir}', self.defaults)
     73        p = self.macros.expand('%{_sbdir}')
    7174        for arg in args:
    7275            p = path.join(p, arg)
     
    8891            except:
    8992                raise error.general('installation error: no asciidocapi found')
    90             asciidoc_py = self._sbpath(defaults.basepath, 'asciidoc', 'asciidoc.py')
     93            asciidoc_py = self._sbpath(options.basepath, 'asciidoc', 'asciidoc.py')
    9194            try:
    9295                self.asciidoc = asciidocapi.AsciiDocAPI(asciidoc_py)
     
    110113            self.output('-' * self.line_len)
    111114            self.output('%s' % (text))
    112         repo = git.repo('.', self.opts, self.defaults)
     115        repo = git.repo('.', self.opts, self.macros)
    113116        repo_valid = repo.valid()
    114117        if repo_valid:
     
    173176            self.output(datetime.datetime.now().ctime())
    174177            self.output('')
    175             image = self._sbpath(defaults.basepath, 'images', 'rtemswhitebg.jpg')
     178            image = self._sbpath(options.basepath, 'images', 'rtemswhitebg.jpg')
    176179            self.output('image:%s["RTEMS",width="20%%"]' % (image))
    177180            self.output('')
     
    249252                self.output('--------------------------------------------')
    250253
    251     def config(self, configname, _defaults, _opts):
    252 
    253         _config = config.file(configname, _defaults = _defaults, opts = _opts)
     254    def config(self, configname, opts, macros):
     255
     256        _config = config.file(configname, opts, macros)
    254257        packages = _config.packages()
    255258        package = packages['main']
     
    309312        self.bset_nesting += 1
    310313        self.buildset_start(name)
    311         _opts = copy.copy(self.opts)
    312         _defaults = copy.copy(self.defaults)
    313         bset = setbuilder.buildset(name,
    314                                    _configs = self.configs,
    315                                    _defaults = _defaults,
    316                                    opts = _opts)
     314        opts = copy.copy(self.opts)
     315        macros = copy.copy(self.macros)
     316        bset = setbuilder.buildset(name, self.configs, opts, macros)
    317317        for c in bset.load():
    318318            if c.endswith('.bset'):
    319319                self.buildset(c)
    320320            elif c.endswith('.cfg'):
    321                 self.config(c, _defaults, _opts)
     321                self.config(c, opts, macros)
    322322            else:
    323323                raise error.general('invalid config type: %s' % (c))
     
    353353            self.buildset(config)
    354354        elif config.endswith('.cfg'):
    355             self.config(config, self.defaults, self.opts)
     355            self.config(config, self.opts, self.macros)
    356356        else:
    357357            raise error.general('invalid config type: %s' % (config))
     
    364364                    '--format':       'Output format (text, html, asciidoc)',
    365365                    '--output':       'File name to output the report' }
    366         opts, _defaults = defaults.load(args, optargs)
     366        opts = options.load(args, optargs)
    367367        log.default = log.log(opts.logfiles())
    368368        if opts.get_arg('--output') and len(opts.params()) > 1:
    369369            raise error.general('--output can only be used with a single config')
    370370        print 'RTEMS Source Builder, Reporter v%s' % (version.str())
    371         if not check.host_setup(opts, _defaults):
     371        if not check.host_setup(opts):
    372372            _notice(opts, 'warning: forcing build with known host setup problems')
    373         configs = build.get_configs(opts, _defaults)
     373        configs = build.get_configs(opts)
    374374        if not setbuilder.list_bset_cfg_files(opts, configs):
    375375            output = opts.get_arg('--output')
     
    392392                else:
    393393                    raise error.general('invalid format: %s' % (format_opt[1]))
    394             r = report(format = format,
    395                        _configs = configs,
    396                        _defaults = _defaults,
    397                        opts = opts)
     394            r = report(format, configs, opts)
    398395            for _config in opts.params():
    399396                if output is None:
    400397                    outname = path.splitext(_config)[0] + ext
     398                    outname = outname.replace('/', '-')
    401399                else:
    402400                    outname = output
  • source-builder/sb/setbuilder.py

    r530a938 rcb12e48  
    3434    import build
    3535    import check
    36     import defaults
    3736    import error
    3837    import log
     38    import options
    3939    import path
    4040    import reports
     
    6060    """Build a set builds a set of packages."""
    6161
    62     def __init__(self, bset, _configs, _defaults, opts):
     62    def __init__(self, bset, _configs, opts, macros = None):
    6363        _trace(opts, '_bset:%s: init' % (bset))
    6464        self.configs = _configs
    6565        self.opts = opts
    66         self.defaults = _defaults
     66        if macros is None:
     67            self.macros = copy.copy(opts.defaults)
     68        else:
     69            self.macros = copy.copy(macros)
    6770        self.bset = bset
    68         self.bset_pkg = '%s-%s-set' % (self.opts.expand('%{_target}', _defaults),
    69                                        self.bset)
     71        self.bset_pkg = '%s-%s-set' % (self.macros.expand('%{_target}'), self.bset)
    7072
    7173    def _output(self, text):
     
    8890
    8991    def report(self, _config, _build):
    90         if not self.opts.get_arg('--no-report'):
    91             format = self.opts.get_arg('--report-format')
     92        if not _build.opts.get_arg('--no-report'):
     93            format = _build.opts.get_arg('--report-format')
    9294            if format is None:
    9395                format = 'html'
     
    108110                    raise error.general('invalid report format: %s' % (format[1]))
    109111            buildroot = _build.config.abspath('%{buildroot}')
    110             prefix = self.opts.expand('%{_prefix}', self.defaults)
     112            prefix = _build.macros.expand('%{_prefix}')
    111113            name = _build.main_package().name() + ext
    112114            outpath = path.host(path.join(buildroot, prefix, 'share', 'rtems-source-builder'))
    113115            outname = path.host(path.join(outpath, name))
    114116            _notice(self.opts, 'reporting: %s -> %s' % (_config, name))
    115             if not self.opts.dry_run():
     117            if not _build.opts.dry_run():
    116118                _build.mkdir(outpath)
    117                 r = reports.report(format, self.configs, self.defaults, self.opts)
     119                r = reports.report(format, self.configs, _build.opts, _build.macros)
    118120                r.make(_config, outname)
    119121                del r
     
    135137
    136138    def canadian_cross(self, _build):
    137         defaults_to_save = ['%{_prefix}',
    138                             '%{_tmproot}',
    139                             '%{buildroot}',
    140                             '%{_builddir}',
    141                             '%{_host}']
    142         defaults_to_copy = [('%{_host}',     '%{_build}'),
    143                             ('%{_tmproot}',  '%{_tmpcxcroot}'),
    144                             ('%{buildroot}', '%{buildcxcroot}'),
    145                             ('%{_builddir}', '%{_buildcxcdir}')]
    146         orig_defaults = {}
    147         for d in defaults_to_save:
    148             orig_defaults[d] = _build.config.default(d)
    149         for d in defaults_to_copy:
    150             _build.config.set_define(d[0], _build.config.default(d[1]))
     139        # @fixme Switch to using a private macros map.
     140        macros_to_save = ['%{_prefix}',
     141                          '%{_tmproot}',
     142                          '%{buildroot}',
     143                          '%{_builddir}',
     144                          '%{_host}']
     145        macros_to_copy = [('%{_host}',     '%{_build}'),
     146                          ('%{_tmproot}',  '%{_tmpcxcroot}'),
     147                          ('%{buildroot}', '%{buildcxcroot}'),
     148                          ('%{_builddir}', '%{_buildcxcdir}')]
     149        orig_macros = {}
     150        for m in macros_to_save:
     151            orig_macros[m] = _build.config.macro(m)
     152        for m in macros_to_copy:
     153            _build.config.set_define(m[0], _build.config.macro(m[1]))
    151154        _build.make()
    152         for d in defaults_to_save:
    153             _build.config.set_define(d, orig_defaults[d])
     155        for m in macris_to_save:
     156            _build.config.set_define(m, orig_macros[m])
    154157        self.root_copy(_build.config.expand('%{buildcxcroot}'),
    155158                       _build.config.expand('%{_tmpcxcroot}'))
     
    187190
    188191        if not path.exists(bsetname):
    189             for cp in self.opts.expand('%{_configdir}', self.defaults).split(':'):
     192            for cp in self.macros.expand('%{_configdir}').split(':'):
    190193                configdir = path.abspath(cp)
    191194                bsetname = path.join(configdir, bset)
     
    215218                ls = l.split()
    216219                if ls[0][-1] == ':' and ls[0][:-1] == 'package':
    217                     self.bset_pkg = self.opts.expand(ls[1].strip(), self.defaults)
    218                     self.defaults['package'] = ('none', 'none', self.bset_pkg)
     220                    self.bset_pkg = self.macros.expand(ls[1].strip())
     221                    self.macros['package'] = self.bset_pkg
    219222                elif ls[0][0] == '%':
    220223                    if ls[0] == '%define':
    221224                        if len(ls) > 2:
    222                             self.opts.define(self.defaults,
    223                                              ls[1].strip(),
    224                                              ' '.join([f.strip() for f in ls[2:]]))
     225                            self.macros.define(ls[1].strip(),
     226                                               ' '.join([f.strip() for f in ls[2:]]))
    225227                        else:
    226                             self.opts.define(self.defaults, ls[1].strip())
     228                            self.macros.define(ls[1].strip())
    227229                    elif ls[0] == '%undefine':
    228230                        if len(ls) > 2:
    229231                            raise error.general('%undefine requires just the name')
    230                         self.opts.undefine(self.defaults, ls[1].strip())
     232                        self.macros.undefine(ls[1].strip())
    231233                    elif ls[0] == '%include':
    232234                        configs += self.parse(ls[1].strip())
     
    249251    def load(self):
    250252
    251         exbset = self.opts.expand(self.bset, self.defaults)
    252 
    253         self.defaults['_bset'] = ('none', 'none', exbset)
     253        exbset = self.macros.expand(self.bset)
     254
     255        self.macros['_bset'] = exbset
    254256
    255257        root, ext = path.splitext(exbset)
     
    281283                    #
    282284                    # Each section of the build set gets a separate set of
    283                     # defaults so we do not contaminate one configuration with
     285                    # macros so we do not contaminate one configuration with
    284286                    # another.
    285287                    #
    286                     _opts = copy.copy(self.opts)
    287                     _defaults = copy.copy(self.defaults)
     288                    opts = copy.copy(self.opts)
     289                    macros = copy.copy(self.macros)
    288290                    if configs[s].endswith('.bset'):
    289                         bs = buildset(configs[s],
    290                                       _configs = self.configs,
    291                                       _defaults = _defaults,
    292                                       opts = _opts)
     291                        bs = buildset(configs[s], self.configs, opts, macros)
    293292                        bs.build(deps)
    294293                        del bs
    295294                    elif configs[s].endswith('.cfg'):
    296                         b = build.build(configs[s],
    297                                         self.opts.get_arg('--pkg-tar-files'),
    298                                         _defaults = _defaults,
    299                                         opts = _opts)
     295                        b = build.build(configs[s], self.opts.get_arg('--pkg-tar-files'),
     296                                        opts, macros)
    300297                        if deps is None:
    301298                            self.build_package(configs[s], b)
     
    361358                    '--bset-tar-file': 'Create a build set tar file',
    362359                    '--pkg-tar-files': 'Create package tar files' }
    363         opts, _defaults = defaults.load(sys.argv, optargs)
     360        opts = options.load(sys.argv, optargs)
    364361        log.default = log.log(opts.logfiles())
    365362        _notice(opts, 'RTEMS Source Builder - Set Builder, v%s' % (version.str()))
    366         if not check.host_setup(opts, _defaults):
     363        if not check.host_setup(opts):
    367364            raise error.general('host build environment is not set up correctly')
    368         configs = build.get_configs(opts, _defaults)
     365        configs = build.get_configs(opts)
    369366        if opts.get_arg('--list-deps'):
    370367            deps = []
     
    373370        if not list_bset_cfg_files(opts, configs):
    374371            for bset in opts.params():
    375                 b = buildset(bset, _configs = configs, _defaults = _defaults, opts = opts)
     372                b = buildset(bset, configs, opts)
    376373                b.build(deps)
    377374                del b
Note: See TracChangeset for help on using the changeset viewer.