Changeset 7bdcc45 in mainline for tools

Timestamp:

2010-12-16T16:38:49Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

7837101

Parents:

8e58f94 (diff), eb221e5 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

tools

Files:

• autotool.py (modified) (9 diffs)
• check.sh (added)
• config.py (modified) (22 diffs)

tools/autotool.py

@@ -49 +49 @@
 
 PACKAGE_BINUTILS = "usually part of binutils"
-PACKAGE_GCC = "preferably version 4.4.3 or newer"
+PACKAGE_GCC = "preferably version 4.5.1 or newer"
 PACKAGE_CROSS = "use tools/toolchain.sh to build the cross-compiler toolchain"
 
 COMPILER_FAIL = "The compiler is probably not capable to compile HelenOS."
-
-PROBE_HEAD = """#define AUTOTOOL_DECLARE(category, subcategory, tag, name, value) \\
+COMPILER_WARNING = "The compilation of HelenOS might fail."
+
+PROBE_HEAD = """#define AUTOTOOL_DECLARE(category, subcategory, tag, name, strc, conc, value) \\
         asm volatile ( \\
-                "AUTOTOOL_DECLARE\\t" category "\\t" subcategory "\\t" tag "\\t" name "\\t%[val]\\n" \\
+                "AUTOTOOL_DECLARE\\t" category "\\t" subcategory "\\t" tag "\\t" name "\\t" strc "\\t" conc "\\t%[val]\\n" \\
                 : \\
                 : [val] "n" (value) \\
         )
 
-#define DECLARE_INTSIZE(tag, type) \\
-        AUTOTOOL_DECLARE("intsize", "unsigned", tag, #type, sizeof(unsigned type)); \\
-        AUTOTOOL_DECLARE("intsize", "signed", tag, #type, sizeof(signed type))
+#define STRING(arg)      STRING_ARG(arg)
+#define STRING_ARG(arg)  #arg
+
+#define DECLARE_BUILTIN_TYPE(tag, type) \\
+        AUTOTOOL_DECLARE("builtin", "", tag, STRING(type), "", "", sizeof(type));
+
+#define DECLARE_INTSIZE(tag, type, strc, conc) \\
+        AUTOTOOL_DECLARE("intsize", "unsigned", tag, #type, strc, conc, sizeof(unsigned type)); \\
+        AUTOTOOL_DECLARE("intsize", "signed", tag, #type, strc, conc, sizeof(signed type));
 
 int main(int argc, char *argv[])
 {
+#ifdef __SIZE_TYPE__
+        DECLARE_BUILTIN_TYPE("size", __SIZE_TYPE__);
+#endif
+#ifdef __WCHAR_TYPE__
+        DECLARE_BUILTIN_TYPE("wchar", __WCHAR_TYPE__);
+#endif
+#ifdef __WINT_TYPE__
+        DECLARE_BUILTIN_TYPE("wint", __WINT_TYPE__);
+#endif
 """
 
@@ -96 +112 @@
         
         sys.exit(1)
+
+def print_warning(msg):
+        "Print a bold error message"
+        
+        sys.stderr.write("\n")
+        sys.stderr.write("######################################################################\n")
+        sys.stderr.write("HelenOS build sanity check warning:\n")
+        sys.stderr.write("\n")
+        sys.stderr.write("%s\n" % "\n".join(msg))
+        sys.stderr.write("######################################################################\n")
+        sys.stderr.write("\n")
+        
+        time.sleep(5)
 
 def sandbox_enter():
@@ -186 +215 @@
         check_app([common['STRIP'], "--version"], "GNU strip", details)
 
+def decode_value(value):
+        "Decode integer value"
+        
+        base = 10
+        
+        if ((value.startswith('$')) or (value.startswith('#'))):
+                value = value[1:]
+        
+        if (value.startswith('0x')):
+                value = value[2:]
+                base = 16
+        
+        return int(value, base)
+
 def probe_compiler(common, sizes):
         "Generate, compile and parse probing source"
@@ -195 +238 @@
         
         for typedef in sizes:
-                outf.write("\tDECLARE_INTSIZE(\"%s\", %s);\n" % (typedef['tag'], typedef['type']))
+                outf.write("\tDECLARE_INTSIZE(\"%s\", %s, %s, %s);\n" % (typedef['tag'], typedef['type'], typedef['strc'], typedef['conc']))
         
         outf.write(PROBE_TAIL)
@@ -231 +274 @@
         signed_tags = {}
         
+        unsigned_strcs = {}
+        signed_strcs = {}
+        
+        unsigned_concs = {}
+        signed_concs = {}
+        
+        builtins = {}
+        
         for j in range(len(lines)):
                 tokens = lines[j].strip().split("\t")
@@ -236 +287 @@
                 if (len(tokens) > 0):
                         if (tokens[0] == "AUTOTOOL_DECLARE"):
-                                if (len(tokens) < 5):
+                                if (len(tokens) < 7):
                                         print_error(["Malformed declaration in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
                                 
@@ -243 +294 @@
                                 tag = tokens[3]
                                 name = tokens[4]
-                                value = tokens[5]
+                                strc = tokens[5]
+                                conc = tokens[6]
+                                value = tokens[7]
                                 
                                 if (category == "intsize"):
-                                        base = 10
-                                        
-                                        if ((value.startswith('$')) or (value.startswith('#'))):
-                                                value = value[1:]
-                                        
-                                        if (value.startswith('0x')):
-                                                value = value[2:]
-                                                base = 16
-                                        
                                         try:
-                                                value_int = int(value, base)
+                                                value_int = decode_value(value)
                                         except:
                                                 print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
                                         
                                         if (subcategory == "unsigned"):
-                                                unsigned_sizes[name] = value_int
+                                                unsigned_sizes[value_int] = name
                                                 unsigned_tags[tag] = value_int
+                                                unsigned_strcs[value_int] = strc
+                                                unsigned_concs[value_int] = conc
                                         elif (subcategory == "signed"):
-                                                signed_sizes[name] = value_int
+                                                signed_sizes[value_int] = name
                                                 signed_tags[tag] = value_int
+                                                signed_strcs[value_int] = strc
+                                                signed_concs[value_int] = conc
                                         else:
                                                 print_error(["Unexpected keyword \"%s\" in \"%s\" on line %s." % (subcategory, PROBE_OUTPUT, j), COMPILER_FAIL])
-        
-        return {'unsigned_sizes' : unsigned_sizes, 'signed_sizes' : signed_sizes, 'unsigned_tags': unsigned_tags, 'signed_tags': signed_tags}
-
-def detect_uints(probe, bytes):
+                                
+                                if (category == "builtin"):
+                                        try:
+                                                value_int = decode_value(value)
+                                        except:
+                                                print_error(["Integer value expected in \"%s\" on line %s." % (PROBE_OUTPUT, j), COMPILER_FAIL])
+                                        
+                                        builtins[tag] = {'name': name, 'value': value_int}
+        
+        return {'unsigned_sizes': unsigned_sizes, 'signed_sizes': signed_sizes, 'unsigned_tags': unsigned_tags, 'signed_tags': signed_tags, 'unsigned_strcs': unsigned_strcs, 'signed_strcs': signed_strcs, 'unsigned_concs': unsigned_concs, 'signed_concs': signed_concs, 'builtins': builtins}
+
+def detect_uints(probe, bytes, tags):
         "Detect correct types for fixed-size integer types"
         
@@ -278 +334 @@
         
         for b in bytes:
+                if (not b in probe['unsigned_sizes']):
+                        print_error(['Unable to find appropriate unsigned integer type for %u bytes' % b,
+                                     COMPILER_FAIL])
+                
+                if (not b in probe['signed_sizes']):
+                        print_error(['Unable to find appropriate signed integer type for %u bytes' % b,
+                                     COMPILER_FAIL])
+                
+                if (not b in probe['unsigned_strcs']):
+                        print_error(['Unable to find appropriate unsigned printf formatter for %u bytes' % b,
+                                     COMPILER_FAIL])
+                
+                if (not b in probe['signed_strcs']):
+                        print_error(['Unable to find appropriate signed printf formatter for %u bytes' % b,
+                                     COMPILER_FAIL])
+                
+                if (not b in probe['unsigned_concs']):
+                        print_error(['Unable to find appropriate unsigned literal macro for %u bytes' % b,
+                                     COMPILER_FAIL])
+                
+                if (not b in probe['signed_concs']):
+                        print_error(['Unable to find appropriate signed literal macro for %u bytes' % b,
+                                     COMPILER_FAIL])
+                
+                typedefs.append({'oldtype': "unsigned %s" % probe['unsigned_sizes'][b], 'newtype': "uint%u_t" % (b * 8)})
+                typedefs.append({'oldtype': "signed %s" % probe['signed_sizes'][b], 'newtype': "int%u_t" % (b * 8)})
+                
+                macros.append({'oldmacro': "\"%so\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIo%u" % (b * 8)})
+                macros.append({'oldmacro': "\"%su\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIu%u" % (b * 8)})
+                macros.append({'oldmacro': "\"%sx\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIx%u" % (b * 8)})
+                macros.append({'oldmacro': "\"%sX\"" % probe['unsigned_strcs'][b], 'newmacro': "PRIX%u" % (b * 8)})
+                macros.append({'oldmacro': "\"%sd\"" % probe['signed_strcs'][b], 'newmacro': "PRId%u" % (b * 8)})
+                
+                name = probe['unsigned_concs'][b]
+                if ((name.startswith('@')) or (name == "")):
+                        macros.append({'oldmacro': "c ## U", 'newmacro': "UINT%u_C(c)" % (b * 8)})
+                else:
+                        macros.append({'oldmacro': "c ## U%s" % name, 'newmacro': "UINT%u_C(c)" % (b * 8)})
+                
+                name = probe['unsigned_concs'][b]
+                if ((name.startswith('@')) or (name == "")):
+                        macros.append({'oldmacro': "c", 'newmacro': "INT%u_C(c)" % (b * 8)})
+                else:
+                        macros.append({'oldmacro': "c ## %s" % name, 'newmacro': "INT%u_C(c)" % (b * 8)})
+        
+        for tag in tags:
+                newmacro = "U%s" % tag
+                if (not tag in probe['unsigned_tags']):
+                        print_error(['Unable to find appropriate size macro for %s' % newmacro,
+                                     COMPILER_FAIL])
+                
+                oldmacro = "UINT%s" % (probe['unsigned_tags'][tag] * 8)
+                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
+                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
+                
+                newmacro = tag
+                if (not tag in probe['unsigned_tags']):
+                        print_error(['Unable to find appropriate size macro for %s' % newmacro,
+                                     COMPILER_FAIL])
+                
+                oldmacro = "INT%s" % (probe['signed_tags'][tag] * 8)
+                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
+                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
+        
+        fnd = True
+        
+        if (not 'wchar' in probe['builtins']):
+                print_warning(['The compiler does not provide the macro __WCHAR_TYPE__',
+                               'for defining the compiler-native type wchar_t. We are',
+                               'forced to define wchar_t as a hardwired type int32_t.',
+                               COMPILER_WARNING])
                 fnd = False
-                newtype = "uint%s_t" % (b * 8)
-                
-                for name, value in probe['unsigned_sizes'].items():
-                        if (value == b):
-                                oldtype = "unsigned %s" % name
-                                typedefs.append({'oldtype' : oldtype, 'newtype' : newtype})
-                                fnd = True
-                                break
-                
-                if (not fnd):
-                        print_error(['Unable to find appropriate integer type for %s' % newtype,
-                                     COMPILER_FAIL])
-                
-                
+        
+        if (probe['builtins']['wchar']['value'] != 4):
+                print_warning(['The compiler provided macro __WCHAR_TYPE__ for defining',
+                               'the compiler-native type wchar_t is not compliant with',
+                               'HelenOS. We are forced to define wchar_t as a hardwired',
+                               'type int32_t.',
+                               COMPILER_WARNING])
                 fnd = False
-                newtype = "int%s_t" % (b * 8)
-                
-                for name, value in probe['signed_sizes'].items():
-                        if (value == b):
-                                oldtype = "signed %s" % name
-                                typedefs.append({'oldtype' : oldtype, 'newtype' : newtype})
-                                fnd = True
-                                break
-                
-                if (not fnd):
-                        print_error(['Unable to find appropriate integer type for %s' % newtype,
-                                     COMPILER_FAIL])
-        
-        for tag in ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG']:
-                fnd = False;
-                newmacro = "U%s" % tag
-                
-                for name, value in probe['unsigned_tags'].items():
-                        if (name == tag):
-                                oldmacro = "UINT%s" % (value * 8)
-                                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
-                                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
-                                fnd = True
-                                break
-                
-                if (not fnd):
-                        print_error(['Unable to find appropriate size macro for %s' % newmacro,
-                                     COMPILER_FAIL])
-                
-                fnd = False;
-                newmacro = tag
-                
-                for name, value in probe['signed_tags'].items():
-                        if (name == tag):
-                                oldmacro = "INT%s" % (value * 8)
-                                macros.append({'oldmacro': "%s_MIN" % oldmacro, 'newmacro': "%s_MIN" % newmacro})
-                                macros.append({'oldmacro': "%s_MAX" % oldmacro, 'newmacro': "%s_MAX" % newmacro})
-                                fnd = True
-                                break
-                
-                if (not fnd):
-                        print_error(['Unable to find appropriate size macro for %s' % newmacro,
-                                     COMPILER_FAIL])
+        
+        if (not fnd):
+                macros.append({'oldmacro': "int32_t", 'newmacro': "wchar_t"})
+        else:
+                macros.append({'oldmacro': "__WCHAR_TYPE__", 'newmacro': "wchar_t"})
+        
+        fnd = True
+        
+        if (not 'wint' in probe['builtins']):
+                print_warning(['The compiler does not provide the macro __WINT_TYPE__',
+                               'for defining the compiler-native type wint_t. We are',
+                               'forced to define wint_t as a hardwired type int32_t.',
+                               COMPILER_WARNING])
+                fnd = False
+        
+        if (probe['builtins']['wint']['value'] != 4):
+                print_warning(['The compiler provided macro __WINT_TYPE__ for defining',
+                               'the compiler-native type wint_t is not compliant with',
+                               'HelenOS. We are forced to define wint_t as a hardwired',
+                               'type int32_t.',
+                               COMPILER_WARNING])
+                fnd = False
+        
+        if (not fnd):
+                macros.append({'oldmacro': "int32_t", 'newmacro': "wint_t"})
+        else:
+                macros.append({'oldmacro': "__WINT_TYPE__", 'newmacro': "wint_t"})
         
         return {'macros': macros, 'typedefs': typedefs}
@@ -508 +612 @@
                 probe = probe_compiler(common,
                         [
-                                {'type': 'char', 'tag': 'CHAR'},
-                                {'type': 'short int', 'tag': 'SHORT'},
-                                {'type': 'int', 'tag': 'INT'},
-                                {'type': 'long int', 'tag': 'LONG'},
-                                {'type': 'long long int', 'tag': 'LLONG'}
+                                {'type': 'long long int', 'tag': 'LLONG', 'strc': '"ll"', 'conc': '"LL"'},
+                                {'type': 'long int', 'tag': 'LONG', 'strc': '"l"', 'conc': '"L"'},
+                                {'type': 'int', 'tag': 'INT', 'strc': '""', 'conc': '""'},
+                                {'type': 'short int', 'tag': 'SHORT', 'strc': '"h"', 'conc': '"@"'},
+                                {'type': 'char', 'tag': 'CHAR', 'strc': '"hh"', 'conc': '"@@"'}
                         ]
                 )
                 
-                maps = detect_uints(probe, [1, 2, 4, 8])
+                maps = detect_uints(probe, [1, 2, 4, 8], ['CHAR', 'SHORT', 'INT', 'LONG', 'LLONG'])
                 
         finally:

tools/config.py

@@ -3 +3 @@
 # Copyright (c) 2006 Ondrej Palkovsky
 # Copyright (c) 2009 Martin Decky
+# Copyright (c) 2010 Jiri Svoboda
 # All rights reserved.
 #
@@ -40 +41 @@
 import xtui
 
-INPUT = sys.argv[1]
+RULES_FILE = sys.argv[1]
 MAKEFILE = 'Makefile.config'
 MACROS = 'config.h'
-PRECONF = 'defaults'
-
-def read_defaults(fname, defaults):
-        "Read saved values from last configuration run"
+PRESETS_DIR = 'defaults'
+
+def read_config(fname, config):
+        "Read saved values from last configuration run or a preset file"
         
         inf = open(fname, 'r')
@@ -52 +53 @@
         for line in inf:
                 res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line)
-                if (res):
-                        defaults[res.group(1)] = res.group(2)
+                if res:
+                        config[res.group(1)] = res.group(2)
         
         inf.close()
 
-def check_condition(text, defaults, ask_names):
+def check_condition(text, config, rules):
         "Check that the condition specified on input line is True (only CNF and DNF is supported)"
         
         ctype = 'cnf'
         
-        if ((')|' in text) or ('|(' in text)):
+        if (')|' in text) or ('|(' in text):
                 ctype = 'dnf'
         
-        if (ctype == 'cnf'):
+        if ctype == 'cnf':
                 conds = text.split('&')
         else:
@@ -71 +72 @@
         
         for cond in conds:
-                if (cond.startswith('(')) and (cond.endswith(')')):
+                if cond.startswith('(') and cond.endswith(')'):
                         cond = cond[1:-1]
                 
-                inside = check_inside(cond, defaults, ctype)
+                inside = check_inside(cond, config, ctype)
                 
                 if (ctype == 'cnf') and (not inside):
                         return False
                 
-                if (ctype == 'dnf') and (inside):
+                if (ctype == 'dnf') and inside:
                         return True
         
-        if (ctype == 'cnf'):
+        if ctype == 'cnf':
                 return True
         return False
 
-def check_inside(text, defaults, ctype):
+def check_inside(text, config, ctype):
         "Check for condition"
         
-        if (ctype == 'cnf'):
+        if ctype == 'cnf':
                 conds = text.split('|')
         else:
@@ -96 +97 @@
         for cond in conds:
                 res = re.match(r'^(.*?)(!?=)(.*)$', cond)
-                if (not res):
+                if not res:
                         raise RuntimeError("Invalid condition: %s" % cond)
                 
@@ -103 +104 @@
                 condval = res.group(3)
                 
-                if (not condname in defaults):
+                if not condname in config:
                         varval = ''
                 else:
-                        varval = defaults[condname]
+                        varval = config[condname]
                         if (varval == '*'):
                                 varval = 'y'
                 
-                if (ctype == 'cnf'):
+                if ctype == 'cnf':
                         if (oper == '=') and (condval == varval):
                                 return True
@@ -123 +124 @@
                                 return False
         
-        if (ctype == 'cnf'):
+        if ctype == 'cnf':
                 return False
         
         return True
 
-def parse_config(fname, ask_names):
-        "Parse configuration file"
+def parse_rules(fname, rules):
+        "Parse rules file"
         
         inf = open(fname, 'r')
@@ -138 +139 @@
         for line in inf:
                 
-                if (line.startswith('!')):
+                if line.startswith('!'):
                         # Ask a question
                         res = re.search(r'!\s*(?:\[(.*?)\])?\s*([^\s]+)\s*\((.*)\)\s*$', line)
                         
-                        if (not res):
+                        if not res:
                                 raise RuntimeError("Weird line: %s" % line)
                         
@@ -149 +150 @@
                         vartype = res.group(3)
                         
-                        ask_names.append((varname, vartype, name, choices, cond))
+                        rules.append((varname, vartype, name, choices, cond))
                         name = ''
                         choices = []
                         continue
                 
-                if (line.startswith('@')):
+                if line.startswith('@'):
                         # Add new line into the 'choices' array
                         res = re.match(r'@\s*(?:\[(.*?)\])?\s*"(.*?)"\s*(.*)$', line)
@@ -164 +165 @@
                         continue
                 
-                if (line.startswith('%')):
+                if line.startswith('%'):
                         # Name of the option
                         name = line[1:].strip()
                         continue
                 
-                if ((line.startswith('#')) or (line == '\n')):
+                if line.startswith('#') or (line == '\n'):
                         # Comment or empty line
                         continue
@@ -181 +182 @@
         "Return '*' if yes, ' ' if no"
         
-        if (default == 'y'):
+        if default == 'y':
                 return '*'
         
@@ -199 +200 @@
         cnt = 0
         for key, val in choices:
-                if ((default) and (key == default)):
+                if (default) and (key == default):
                         position = cnt
                 
@@ -207 +208 @@
         (button, value) = xtui.choice_window(screen, name, 'Choose value', options, position)
         
-        if (button == 'cancel'):
+        if button == 'cancel':
                 return None
         
         return choices[value][0]
 
-def check_choices(defaults, ask_names):
-        "Check whether all accessible variables have a default"
-        
-        for varname, vartype, name, choices, cond in ask_names:
-                if ((cond) and (not check_condition(cond, defaults, ask_names))):
+## Infer and verify configuration values.
+#
+# Augment @a config with values that can be inferred, purge invalid ones
+# and verify that all variables have a value (previously specified or inferred).
+#
+# @param config Configuration to work on
+# @param rules  Rules
+#
+# @return True if configuration is complete and valid, False
+#         otherwise.
+#
+def infer_verify_choices(config, rules):
+        "Infer and verify configuration values."
+        
+        for rule in rules:
+                varname, vartype, name, choices, cond = rule
+                
+                if cond and (not check_condition(cond, config, rules)):
                         continue
                 
-                if (not varname in defaults):
+                if not varname in config:
+                        value = None
+                else:
+                        value = config[varname]
+                
+                if not validate_rule_value(rule, value):
+                        value = None
+                
+                default = get_default_rule(rule)
+
+                #
+                # If we don't have a value but we do have
+                # a default, use it.
+                #
+                if value == None and default != None:
+                        value = default
+                        config[varname] = default
+                
+                if not varname in config:
                         return False
         
         return True
 
-def create_output(mkname, mcname, defaults, ask_names):
+## Get default value from a rule.
+def get_default_rule(rule):
+        varname, vartype, name, choices, cond = rule
+        
+        default = None
+        
+        if vartype == 'choice':
+                # If there is just one option, use it
+                if len(choices) == 1:
+                        default = choices[0][0]
+        elif vartype == 'y':
+                default = '*'
+        elif vartype == 'n':
+                default = 'n'
+        elif vartype == 'y/n':
+                default = 'y'
+        elif vartype == 'n/y':
+                default = 'n'
+        else:
+                raise RuntimeError("Unknown variable type: %s" % vartype)
+        
+        return default
+
+## Get option from a rule.
+#
+# @param rule  Rule for a variable
+# @param value Current value of the variable
+#
+# @return Option (string) to ask or None which means not to ask.
+#
+def get_rule_option(rule, value):
+        varname, vartype, name, choices, cond = rule
+        
+        option = None
+        
+        if vartype == 'choice':
+                # If there is just one option, don't ask
+                if len(choices) != 1:
+                        if (value == None):
+                                option = "?     %s --> " % name
+                        else:
+                                option = "      %s [%s] --> " % (name, value)
+        elif vartype == 'y':
+                pass
+        elif vartype == 'n':
+                pass
+        elif vartype == 'y/n':
+                option = "  <%s> %s " % (yes_no(value), name)
+        elif vartype == 'n/y':
+                option ="  <%s> %s " % (yes_no(value), name)
+        else:
+                raise RuntimeError("Unknown variable type: %s" % vartype)
+        
+        return option
+
+## Check if variable value is valid.
+#
+# @param rule  Rule for the variable
+# @param value Value of the variable
+#
+# @return True if valid, False if not valid.
+#
+def validate_rule_value(rule, value):
+        varname, vartype, name, choices, cond = rule
+        
+        if value == None:
+                return True
+        
+        if vartype == 'choice':
+                if not value in [choice[0] for choice in choices]:
+                        return False
+        elif vartype == 'y':
+                if value != 'y':
+                        return False
+        elif vartype == 'n':
+                if value != 'n':
+                        return False
+        elif vartype == 'y/n':
+                if not value in ['y', 'n']:
+                        return False
+        elif vartype == 'n/y':
+                if not value in ['y', 'n']:
+                        return False
+        else:
+                raise RuntimeError("Unknown variable type: %s" % vartype)
+        
+        return True
+
+def create_output(mkname, mcname, config, rules):
         "Create output configuration"
         
@@ -238 +358 @@
                 sys.stderr.write("failed\n")
         
-        if (len(version) == 3):
+        if len(version) == 3:
                 revision = version[1]
-                if (version[0] != 1):
+                if version[0] != 1:
                         revision += 'M'
                 revision += ' (%s)' % version[2]
@@ -259 +379 @@
         defs = 'CONFIG_DEFS ='
         
-        for varname, vartype, name, choices, cond in ask_names:
-                if ((cond) and (not check_condition(cond, defaults, ask_names))):
+        for varname, vartype, name, choices, cond in rules:
+                if cond and (not check_condition(cond, config, rules)):
                         continue
                 
-                if (not varname in defaults):
-                        default = ''
+                if not varname in config:
+                        value = ''
                 else:
-                        default = defaults[varname]
-                        if (default == '*'):
-                                default = 'y'
-                
-                outmk.write('# %s\n%s = %s\n\n' % (name, varname, default))
-                
-                if ((vartype == "y") or (vartype == "n") or (vartype == "y/n") or (vartype == "n/y")):
-                        if (default == "y"):
+                        value = config[varname]
+                        if (value == '*'):
+                                value = 'y'
+                
+                outmk.write('# %s\n%s = %s\n\n' % (name, varname, value))
+                
+                if vartype in ["y", "n", "y/n", "n/y"]:
+                        if value == "y":
                                 outmc.write('/* %s */\n#define %s\n\n' % (name, varname))
                                 defs += ' -D%s' % varname
                 else:
-                        outmc.write('/* %s */\n#define %s %s\n#define %s_%s\n\n' % (name, varname, default, varname, default))
-                        defs += ' -D%s=%s -D%s_%s' % (varname, default, varname, default)
-        
-        if (revision is not None):
+                        outmc.write('/* %s */\n#define %s %s\n#define %s_%s\n\n' % (name, varname, value, varname, value))
+                        defs += ' -D%s=%s -D%s_%s' % (varname, value, varname, value)
+        
+        if revision is not None:
                 outmk.write('REVISION = %s\n' % revision)
                 outmc.write('#define REVISION %s\n' % revision)
@@ -299 +419 @@
         return list
 
-def read_preconfigured(root, fname, screen, defaults):
+## Ask user to choose a configuration profile.
+#
+def choose_profile(root, fname, screen, config):
         options = []
         opt2path = {}
@@ -309 +431 @@
                 canon = os.path.join(path, fname)
                 
-                if ((os.path.isdir(path)) and (os.path.exists(canon)) and (os.path.isfile(canon))):
+                if os.path.isdir(path) and os.path.exists(canon) and os.path.isfile(canon):
                         subprofile = False
                         
@@ -317 +439 @@
                                 subcanon = os.path.join(subpath, fname)
                                 
-                                if ((os.path.isdir(subpath)) and (os.path.exists(subcanon)) and (os.path.isfile(subcanon))):
+                                if os.path.isdir(subpath) and os.path.exists(subcanon) and os.path.isfile(subcanon):
                                         subprofile = True
                                         options.append("%s (%s)" % (name, subname))
-                                        opt2path[cnt] = (canon, subcanon)
+                                        opt2path[cnt] = [name, subname]
                                         cnt += 1
                         
-                        if (not subprofile):
+                        if not subprofile:
                                 options.append(name)
-                                opt2path[cnt] = (canon, None)
+                                opt2path[cnt] = [name]
                                 cnt += 1
         
         (button, value) = xtui.choice_window(screen, 'Load preconfigured defaults', 'Choose configuration profile', options, None)
         
-        if (button == 'cancel'):
+        if button == 'cancel':
                 return None
         
-        read_defaults(opt2path[value][0], defaults)
-        if (opt2path[value][1] != None):
-                read_defaults(opt2path[value][1], defaults)
+        return opt2path[value]
+
+## Read presets from a configuration profile.
+#
+# @param profile Profile to load from (a list of string components)
+# @param config  Output configuration
+#
+def read_presets(profile, config):
+        path = os.path.join(PRESETS_DIR, profile[0], MAKEFILE)
+        read_config(path, config)
+        
+        if len(profile) > 1:
+                path = os.path.join(PRESETS_DIR, profile[0], profile[1], MAKEFILE)
+                read_config(path, config)
+
+## Parse profile name (relative OS path) into a list of components.
+#
+# @param profile_name Relative path (using OS separator)
+# @return             List of components
+#
+def parse_profile_name(profile_name):
+        profile = []
+        
+        head, tail = os.path.split(profile_name)
+        if head != '':
+                profile.append(head)
+        
+        profile.append(tail)
+        return profile
 
 def main():
-        defaults = {}
-        ask_names = []
-        
-        # Parse configuration file
-        parse_config(INPUT, ask_names)
-        
-        # Read defaults from previous run
-        if os.path.exists(MAKEFILE):
-                read_defaults(MAKEFILE, defaults)
-        
-        # Default mode: only check defaults and regenerate configuration
-        if ((len(sys.argv) >= 3) and (sys.argv[2] == 'default')):
-                if (check_choices(defaults, ask_names)):
-                        create_output(MAKEFILE, MACROS, defaults, ask_names)
+        profile = None
+        config = {}
+        rules = []
+        
+        # Parse rules file
+        parse_rules(RULES_FILE, rules)
+        
+        # Input configuration file can be specified on command line
+        # otherwise configuration from previous run is used.
+        if len(sys.argv) >= 4:
+                profile = parse_profile_name(sys.argv[3])
+                read_presets(profile, config)
+        elif os.path.exists(MAKEFILE):
+                read_config(MAKEFILE, config)
+        
+        # Default mode: check values and regenerate configuration files
+        if (len(sys.argv) >= 3) and (sys.argv[2] == 'default'):
+                if (infer_verify_choices(config, rules)):
+                        create_output(MAKEFILE, MACROS, config, rules)
                         return 0
         
-        # Check mode: only check defaults
-        if ((len(sys.argv) >= 3) and (sys.argv[2] == 'check')):
-                if (check_choices(defaults, ask_names)):
+        # Hands-off mode: check values and regenerate configuration files,
+        # but no interactive fallback
+        if (len(sys.argv) >= 3) and (sys.argv[2] == 'hands-off'):
+                # We deliberately test sys.argv >= 4 because we do not want
+                # to read implicitly any possible previous run configuration
+                if len(sys.argv) < 4:
+                        sys.stderr.write("Configuration error: No presets specified\n")
+                        return 2
+                
+                if (infer_verify_choices(config, rules)):
+                        create_output(MAKEFILE, MACROS, config, rules)
+                        return 0
+                
+                sys.stderr.write("Configuration error: The presets are ambiguous\n")
+                return 1
+        
+        # Check mode: only check configuration
+        if (len(sys.argv) >= 3) and (sys.argv[2] == 'check'):
+                if infer_verify_choices(config, rules):
                         return 0
                 return 1
@@ -366 +535 @@
                 while True:
                         
-                        # Cancel out all defaults which have to be deduced
-                        for varname, vartype, name, choices, cond in ask_names:
-                                if ((vartype == 'y') and (varname in defaults) and (defaults[varname] == '*')):
-                                        defaults[varname] = None
+                        # Cancel out all values which have to be deduced
+                        for varname, vartype, name, choices, cond in rules:
+                                if (vartype == 'y') and (varname in config) and (config[varname] == '*'):
+                                        config[varname] = None
                         
                         options = []
@@ -377 +546 @@
                         options.append("  --- Load preconfigured defaults ... ")
                         
-                        for varname, vartype, name, choices, cond in ask_names:
-                                
-                                if ((cond) and (not check_condition(cond, defaults, ask_names))):
+                        for rule in rules:
+                                varname, vartype, name, choices, cond = rule
+                                
+                                if cond and (not check_condition(cond, config, rules)):
                                         continue
                                 
-                                if (varname == selname):
+                                if varname == selname:
                                         position = cnt
                                 
-                                if (not varname in defaults):
-                                        default = None
+                                if not varname in config:
+                                        value = None
                                 else:
-                                        default = defaults[varname]
-                                
-                                if (vartype == 'choice'):
-                                        # Check if the default is an acceptable value
-                                        if ((default) and (not default in [choice[0] for choice in choices])):
-                                                default = None
-                                                defaults.pop(varname)
-                                        
-                                        # If there is just one option, use it
-                                        if (len(choices) == 1):
-                                                defaults[varname] = choices[0][0]
-                                                continue
-                                        
-                                        if (default == None):
-                                                options.append("?     %s --> " % name)
-                                        else:
-                                                options.append("      %s [%s] --> " % (name, default))
-                                elif (vartype == 'y'):
-                                        defaults[varname] = '*'
+                                        value = config[varname]
+                                
+                                if not validate_rule_value(rule, value):
+                                        value = None
+                                
+                                default = get_default_rule(rule)
+
+                                #
+                                # If we don't have a value but we do have
+                                # a default, use it.
+                                #
+                                if value == None and default != None:
+                                        value = default
+                                        config[varname] = default
+                                
+                                option = get_rule_option(rule, value)
+                                if option != None:
+                                        options.append(option)
+                                else:
                                         continue
-                                elif (vartype == 'n'):
-                                        defaults[varname] = 'n'
-                                        continue
-                                elif (vartype == 'y/n'):
-                                        if (default == None):
-                                                default = 'y'
-                                                defaults[varname] = default
-                                        options.append("  <%s> %s " % (yes_no(default), name))
-                                elif (vartype == 'n/y'):
-                                        if (default == None):
-                                                default = 'n'
-                                                defaults[varname] = default
-                                        options.append("  <%s> %s " % (yes_no(default), name))
-                                else:
-                                        raise RuntimeError("Unknown variable type: %s" % vartype)
                                 
                                 opt2row[cnt] = (varname, vartype, name, choices)
@@ -433 +588 @@
                         (button, value) = xtui.choice_window(screen, 'HelenOS configuration', 'Choose configuration option', options, position)
                         
-                        if (button == 'cancel'):
+                        if button == 'cancel':
                                 return 'Configuration canceled'
                         
-                        if (button == 'done'):
-                                if (check_choices(defaults, ask_names)):
+                        if button == 'done':
+                                if (infer_verify_choices(config, rules)):
                                         break
                                 else:
@@ -443 +598 @@
                                         continue
                         
-                        if (value == 0):
-                                read_preconfigured(PRECONF, MAKEFILE, screen, defaults)
+                        if value == 0:
+                                profile = choose_profile(PRESETS_DIR, MAKEFILE, screen, config)
+                                if profile != None:
+                                        read_presets(profile, config)
                                 position = 1
                                 continue
                         
                         position = None
-                        if (not value in opt2row):
+                        if not value in opt2row:
                                 raise RuntimeError("Error selecting value: %s" % value)
                         
                         (selname, seltype, name, choices) = opt2row[value]
                         
-                        if (not selname in defaults):
-                                        default = None
+                        if not selname in config:
+                                value = None
                         else:
-                                default = defaults[selname]
-                        
-                        if (seltype == 'choice'):
-                                defaults[selname] = subchoice(screen, name, choices, default)
-                        elif ((seltype == 'y/n') or (seltype == 'n/y')):
-                                if (defaults[selname] == 'y'):
-                                        defaults[selname] = 'n'
+                                value = config[selname]
+                        
+                        if seltype == 'choice':
+                                config[selname] = subchoice(screen, name, choices, value)
+                        elif (seltype == 'y/n') or (seltype == 'n/y'):
+                                if config[selname] == 'y':
+                                        config[selname] = 'n'
                                 else:
-                                        defaults[selname] = 'y'
+                                        config[selname] = 'y'
         finally:
                 xtui.screen_done(screen)
         
-        create_output(MAKEFILE, MACROS, defaults, ask_names)
+        create_output(MAKEFILE, MACROS, config, rules)
         return 0