Subversion Repositories HelenOS

HelenOS configuration script

HelenOS configuration system

OUTPUT = 'Makefile.config'

MAKEFILE = 'Makefile.config'

TMPOUTPUT = 'Makefile.config.tmp'

MACROS = 'config.h'

class DefaultDialog:

def read_defaults(fname, defaults):

    "Wrapper dialog that tries to return default values"

    "Read saved values from last configuration run"

    def __init__(self, dlg):

        self.dlg = dlg

    inf = file(fname, 'r')

    def set_title(self,text):

    for line in inf:

        self.dlg.set_title(text)

        res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line)

        if (res):

    def yesno(self, text, default=None):

            defaults[res.group(1)] = res.group(2)

        if default is not None:

            return default

    inf.close()

        return self.dlg.yesno(text, default)

    def noyes(self, text, default=None):

def check_condition(text, defaults, ask_names):

        if default is not None:

    "Check that the condition specified on input line is True (only CNF and DNF is supported)"

            return default

        return self.dlg.noyes(text, default)

    ctype = 'cnf'

    def choice(self, text, choices, defopt=None):

    if ((')|' in text) or ('|(' in text)):

        if defopt is not None:

        ctype = 'dnf'

            return choices[defopt][0]

        return self.dlg.choice(text, choices, defopt)

    if (ctype == 'cnf'):

        conds = text.split('&')

class NoDialog:

    else:

    def __init__(self):

        conds = text.split('|')

        self.printed = None

        self.title = 'HelenOS Configuration'

    for cond in conds:

        if (cond.startswith('(')) and (cond.endswith(')')):

    def print_title(self):

            cond = cond[1:-1]

        if not self.printed:

            sys.stdout.write("\n*** %s ***\n" % self.title)

        inside = check_inside(cond, defaults, ctype)

            self.printed = True

        if (ctype == 'cnf') and (not inside):

    def set_title(self, text):

            return False

        self.title = text

        self.printed = False

        if (ctype == 'dnf') and (inside):

            return True

    def noyes(self, text, default=None):

        if not default:

    if (ctype == 'cnf'):

            default = 'n'

        return True

        return self.yesno(text, default)

    return False

    def yesno(self, text, default=None):

def check_inside(text, defaults, ctype):

        self.print_title()

    "Check for condition"

        if default != 'n':

    if (ctype == 'cnf'):

            default = 'y'

        conds = text.split('|')

        while 1:

    else:

            sys.stdout.write("%s (y/n)[%s]: " % (text,default))

        conds = text.split('&')

            inp = sys.stdin.readline()

            if not inp:

    for cond in conds:

                raise EOFError

        res = re.match(r'^(.*?)(!?=)(.*)$', cond)

            inp = inp.strip().lower()

        if (not res):

            if not inp:

            raise RuntimeError("Invalid condition: %s" % cond)

                return default

            if inp == 'y':

        condname = res.group(1)

                return 'y'

        oper = res.group(2)

            elif inp == 'n':

        condval = res.group(3)

                return 'n'

        if (not defaults.has_key(condname)):

    def _print_choice(self, text, choices, defopt):

            varval = ''

        sys.stdout.write('%s:\n' % text)

        else:

        for i,(text,descr) in enumerate(choices):

            varval = defaults[condname]

            if descr is '':

            if (varval == '*'):

                sys.stdout.write('\t%2d. %s\n' % (i, text))

                varval = 'y'

            else:

                sys.stdout.write('\t%2d. %s\n' % (i, descr))

        if (ctype == 'cnf'):

        if defopt is not None:

            if (oper == '=') and (condval == varval):

            sys.stdout.write('Enter choice number[%d]: ' % defopt)

                return True

        else:

            sys.stdout.write('Enter choice number: ')

            if (oper == '!=') and (condval != varval):

                return True

    def menu(self, text, choices, button, defopt=None):

        else:

        self.title = 'Main menu'

            if (oper == '=') and (condval != varval):

        menu = []

                return False

        for key, descr in choices:

            txt = key + (45-len(key))*' ' + ': ' + descr

            if (oper == '!=') and (condval == varval):

            menu.append((key, txt))

                return False

        return self.choice(text, [button] + menu)

    if (ctype == 'cnf'):

        return False

    def choice(self, text, choices, defopt=None):

        self.print_title()

    return True

        while 1:

            self._print_choice(text, choices, defopt)

def parse_config(fname, ask_names):

            inp = sys.stdin.readline()

    "Parse configuration file"

            if not inp:

                raise EOFError

    inf = file(fname, 'r')

            if not inp.strip():

                if defopt is not None:

    name = ''

                    return choices[defopt][0]

    choices = []

                continue

            try:

    for line in inf:

                number = int(inp.strip())

            except ValueError:

        if (line.startswith('!')):

                continue

            # Ask a question

            if number < 0 or number >= len(choices):

            res = re.search(r'!\s*(?:\[(.*?)\])?\s*([^\s]+)\s*\((.*)\)\s*$', line)

                continue

            return choices[number][0]

            if (not res):

                raise RuntimeError("Weird line: %s" % line)

def eof_checker(fnc):

            cond = res.group(1)

    def wrapper(self, *args, **kw):

            varname = res.group(2)

        try:

            vartype = res.group(3)

            return fnc(self, *args, **kw)

        except EOFError:

            ask_names.append((varname, vartype, name, choices, cond))

            return getattr(self.bckdialog,fnc.func_name)(*args, **kw)

            name = ''

    return wrapper

            choices = []

            continue

class Dialog(NoDialog):

    def __init__(self):

        if (line.startswith('@')):

        NoDialog.__init__(self)

            # Add new line into the 'choices' array

        self.dlgcmd = os.environ.get('DIALOG','dialog')

            res = re.match(r'@\s*(?:\[(.*?)\])?\s*"(.*?)"\s*(.*)$', line)

        self.title = ''

        self.backtitle = 'HelenOS Configuration'

            if not res:

                raise RuntimeError("Bad line: %s" % line)

        if os.system('%s --print-maxsize >/dev/null 2>&1' % self.dlgcmd) != 0:

            raise NotImplementedError

            choices.append((res.group(2), res.group(3)))

            continue

        self.bckdialog = NoDialog()

        if (line.startswith('%')):

    def set_title(self,text):

            # Name of the option

        self.title = text

            name = line[1:].strip()

        self.bckdialog.set_title(text)

            continue

    def calldlg(self,*args,**kw):

        if ((line.startswith('#')) or (line == '\n')):

        "Wrapper for calling 'dialog' program"

            # Comment or empty line

        indesc, outdesc = os.pipe()

            continue

        pid = os.fork()

        if not pid:

            os.close(2)

        raise RuntimeError("Unknown syntax: %s" % line)

            os.dup(outdesc)

            os.close(indesc)

    inf.close()

            dlgargs = [self.dlgcmd,'--title',self.title,

def yes_no(default):

                       '--backtitle', self.backtitle]

    "Return '*' if yes, ' ' if no"

            for key,val in kw.items():

                dlgargs.append('--'+key)

    if (default == 'y'):

                dlgargs.append(val)

        return '*'

            dlgargs += args            

            os.execlp(self.dlgcmd,*dlgargs)

    return ' '

        os.close(outdesc)

def subchoice(screen, name, choices, default):

    "Return choice of choices"

        try:

            errout = os.fdopen(indesc,'r')

    maxkey = 0

            data = errout.read()

    for key, val in choices:

            errout.close()

        length = len(key)

            pid,status = os.wait()

        if (length > maxkey):

        except:

            maxkey = length

            os.system('reset') # Reset terminal

            raise

    options = []

    position = None

        if not os.WIFEXITED(status):

    cnt = 0

            os.system('reset') # Reset terminal

    for key, val in choices:

            raise EOFError

        if ((default) and (key == default)):

            position = cnt

        status = os.WEXITSTATUS(status)

        if status == 255:

        options.append(" %-*s  %s " % (maxkey, key, val))

            raise EOFError

        cnt += 1

        return status,data

    (button, value) = xtui.choice_window(screen, name, 'Choose value', options, position)

    def yesno(self, text, default=None):

        if text[-1] not in ('?',':'):

    if (button == 'cancel'):

            text = text + ':'

        return None

        width = '50'

        height = '5'

    return choices[value][0]

        if len(text) < 48:

            text = ' '*int(((48-len(text))/2)) + text

def check_choices(defaults, ask_names):

        else:

    "Check whether all accessible variables have a default"

            width = '0'

            height = '0'

    for varname, vartype, name, choices, cond in ask_names:

        if default == 'n':

        if ((cond) and (not check_condition(cond, defaults, ask_names))):

            res,data = self.calldlg('--defaultno','--yesno',text,height,width)

            continue

        else:

            res,data = self.calldlg('--yesno',text,height,width)

        if (not defaults.has_key(varname)):

            return False

        if res == 0:

            return 'y'

    return True

        return 'n'

    yesno = eof_checker(yesno)

def create_output(mkname, mcname, dfname, defaults, ask_names):

    "Create output configuration"

    def menu(self, text, choices, button, defopt=None):

        self.title = 'Main menu'

    revision = commands.getoutput('svnversion . 2> /dev/null')

        text = text + ':'

    timestamp = commands.getoutput('date "+%Y-%m-%d %H:%M:%S"')

        width = '70'

        height = str(8 + len(choices))

    outmk = file(mkname, 'w')

        args = []

    outmc = file(mcname, 'w')

        for key,val in choices:

    outdf = file(dfname, 'w')

            args.append(key)

            args.append(val)

    outmk.write('#########################################\n')

    outmk.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')

        kw = {}

    outmk.write('#########################################\n\n')

        if defopt:

            kw['default-item'] = choices[defopt][0]

    outmc.write('/***************************************\n')

        res,data = self.calldlg('--ok-label','Change',

    outmc.write(' * AUTO-GENERATED FILE, DO NOT EDIT!!! *\n')

                                '--extra-label',button[1],

    outmc.write(' ***************************************/\n\n')

                                '--extra-button',

                                '--menu',text,height,width,

    outdf.write('#########################################\n')

                                str(len(choices)),*args,**kw)

    outdf.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')

        if res == 3:

    outdf.write('#########################################\n\n')

            return button[0]

    outdf.write('CONFIG_DEFS =')

        if res == 1: # Cancel

            sys.exit(1)

    for varname, vartype, name, choices, cond in ask_names:

        elif res:

        if ((cond) and (not check_condition(cond, defaults, ask_names))):

            print data

            continue

            raise EOFError

        return data

        if (not defaults.has_key(varname)):

    menu = eof_checker(menu)

            default = ''

        else:

    def choice(self, text, choices, defopt=None):

            default = defaults[varname]

        text = text + ':'

            if (default == '*'):

        width = '50'

                default = 'y'

        height = str(8 + len(choices))

        args = []

        outmk.write('# %s\n%s = %s\n\n' % (name, varname, default))

        for key,val in choices:

            args.append(key)

        if ((vartype == "y") or (vartype == "n") or (vartype == "y/n") or (vartype == "n/y")):

            args.append(val)

            if (default == "y"):

                outmc.write('/* %s */\n#define %s\n\n' % (name, varname))

        kw = {}

                outdf.write(' -D%s' % varname)

        if defopt:

        else:

            kw['default-item'] = choices[defopt][0]

            outmc.write('/* %s */\n#define %s %s\n#define %s_%s\n\n' % (name, varname, default, varname, default))

        res,data = self.calldlg('--nocancel','--menu',text,height,width,

            outdf.write(' -D%s=%s -D%s_%s' % (varname, default, varname, default))

                                str(len(choices)),*args, **kw)

        if res:

    outmk.write('REVISION = %s\n' % revision)

            print data

    outmk.write('TIMESTAMP = %s\n' % timestamp)

            raise EOFError

        return data

    outmc.write('#define REVISION %s\n' % revision)

    choice = eof_checker(choice)

    outmc.write('#define TIMESTAMP %s\n' % timestamp)

def read_defaults(fname,defaults):

    outdf.write(' "-DREVISION=%s" "-DTIMESTAMP=%s"\n' % (revision, timestamp))

    "Read saved values from last configuration run"

    f = file(fname,'r')

    outmk.close()

    for line in f:

    outmc.close()

        res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line)

    outdf.close()

        if res:

            defaults[res.group(1)] = res.group(2)

def sorted_dir(root):

    f.close()

    list = os.listdir(root)

    list.sort()

def check_condition(text, defaults, asked_names):

    return list

    seen_vars = [ x[0] for x in asked_names ]

    ctype = 'cnf'

def read_preconfigured(root, fname, screen, defaults):

    if ')|' in text or '|(' in text:

    options = []

        ctype = 'dnf'

    opt2path = {}

    cnt = 0

    if ctype == 'cnf':

        conds = text.split('&')

    # Look for profiles

    else:

    for name in sorted_dir(root):

        conds = text.split('|')

        path = os.path.join(root, name)

        canon = os.path.join(path, fname)

    for cond in conds:

        if cond.startswith('(') and cond.endswith(')'):

        if ((os.path.isdir(path)) and (os.path.exists(canon)) and (os.path.isfile(canon))):

            cond = cond[1:-1]

            subprofile = False

        inside = check_inside(cond, defaults, ctype, seen_vars)

            # Look for subprofiles

            for subname in sorted_dir(path):

        if ctype == 'cnf' and not inside:

                subpath = os.path.join(path, subname)

            return False

                subcanon = os.path.join(subpath, fname)

        if ctype == 'dnf' and inside:

            return True

                if ((os.path.isdir(subpath)) and (os.path.exists(subcanon)) and (os.path.isfile(subcanon))):

                    subprofile = True

    if ctype == 'cnf':

                    options.append("%s (%s)" % (name, subname))

        return True

                    opt2path[cnt] = (canon, subcanon)

    return False

                    cnt += 1

def check_inside(text, defaults, ctype, seen_vars):

            if (not subprofile):

    """

                options.append(name)

    Check that the condition specified on input line is True

                opt2path[cnt] = (canon, None)

                cnt += 1

    only CNF is supported

    """

    (button, value) = xtui.choice_window(screen, 'Load preconfigured defaults', 'Choose configuration profile', options, None)

    if ctype == 'cnf':

        conds = text.split('|')

    if (button == 'cancel'):

    else:

        return None

        conds = text.split('&')

    for cond in conds:

    read_defaults(opt2path[value][0], defaults)

        res = re.match(r'^(.*?)(!?=)(.*)$', cond)

    if (opt2path[value][1] != None):

        if not res:

        read_defaults(opt2path[value][1], defaults)

    defaults = {}

    defaults = {}

    try:

    ask_names = []

        dlg = Dialog()

    # Parse configuration file

    except NotImplementedError:

    parse_config(INPUT, ask_names)

        dlg = NoDialog()

    # Read defaults from previous run

    if len(sys.argv) >= 3 and sys.argv[2]=='default':

    if ((len(sys.argv) >= 3) and (sys.argv[2] == 'default')):

        defmode = True

        if (check_choices(defaults, ask_names)):

    else:

            return 0

        defmode = False

    # Check mode: only check defaults

    # Default run will update the configuration file

            # Cancel out all defaults which have to be deduced

    # with newest options

                    defaults[varname] = None

    if os.path.exists(OUTPUT):

            options = []

        read_defaults(OUTPUT, defaults)

            options.append("  --- Load preconfigured defaults ... ")

    # Get ARCH from command line if specified

            for varname, vartype, name, choices, cond in ask_names:

    if len(sys.argv) >= 4:

                if (varname == selname):

        defaults['ARCH'] = sys.argv[3]

                if (not defaults.has_key(varname)):

        defaults['PLATFORM'] = sys.argv[3]

                    default = defaults[varname]

    # Get COMPILER from command line if specified

                    # Check if the default is an acceptable value

    if len(sys.argv) >= 5:

                        default = None

        defaults['COMPILER'] = sys.argv[4]

                        defaults.pop(varname)

    # Get CONFIG_DEBUG from command line if specified

                    # If there is just one option, use it

    if len(sys.argv) >= 6:

                    if (len(choices) == 1):

        defaults['CONFIG_DEBUG'] = sys.argv[5]

                        defaults[varname] = choices[0][0]

    # Get MACHINE/IMAGE from command line if specified

                        options.append("?     %s --> " % name)

    if len(sys.argv) >= 7:

                elif (vartype == 'y'):

        defaults['MACHINE'] = sys.argv[6]

                    defaults[varname] = '*'

        defaults['IMAGE'] = sys.argv[6]

                    defaults[varname] = 'n'

                    continue

    # Dry run only with defaults

                    if (default == None):

    varnames = parse_config(INPUT, TMPOUTPUT, DefaultDialog(dlg), defaults)

                        defaults[varname] = default

    # If not in default mode, present selection of all possibilities

                    options.append("  <%s> %s " % (yes_no(default), name))

    if not defmode:

                elif (vartype == 'n/y'):

        defopt = 0

                    if (default == None):

        while 1:

                        default = 'n'

            # varnames contains variable names that were in the

                        defaults[varname] = default

            # last question set

                    options.append("  <%s> %s " % (yes_no(default), name))

            choices = [ (x[1],defaults[x[0]]) for x in varnames ]

                    raise RuntimeError("Unknown variable type: %s" % vartype)

            res = dlg.menu('Configuration',choices,('save','Save'),defopt)

                opt2row[cnt] = (varname, vartype, name, choices)

            if res == 'save':

            if (position >= options):

                parse_config(INPUT, TMPOUTPUT, DefaultDialog(dlg), defaults)

            (button, value) = xtui.choice_window(screen, 'HelenOS configuration', 'Choose configuration option', options, position)

                break

            if (button == 'cancel'):

            # transfer description back to varname

                return 'Configuration canceled'

            for i,(vname,descr) in enumerate(varnames):

            if (button == 'done'):

                if res == descr:

                if (check_choices(defaults, ask_names)):

                    defopt = i

                    continue

                    break

            if (value == 0):

            # Ask the user a simple question, produce output

                read_preconfigured(PRECONF, MAKEFILE, screen, defaults)

            # as if the user answered all the other questions

            position = None

            # with default answer

            if (not opt2row.has_key(value)):

            varnames = parse_config(INPUT, TMPOUTPUT, dlg, defaults,

                raise RuntimeError("Error selecting value: %s" % value)

                                    askonly=varnames[i][0])

            (selname, seltype, name, choices) = opt2row[value]

            else:

    if os.path.exists(OUTPUT):

            if (seltype == 'choice'):

        os.unlink(OUTPUT)

                if (defaults[selname] == 'y'):

    os.rename(TMPOUTPUT, OUTPUT)

                    defaults[selname] = 'n'

                else:

    if not defmode and dlg.yesno('Rebuild everything?') == 'y':

                    defaults[selname] = 'y'

        os.execlp('make','make','clean','build')

    create_output(MAKEFILE, MACROS, DEFS, defaults, ask_names)

    main()

    sys.exit(main())