Initial commit

tools/cml2-tools/cml.py

@@ -0,0 +1,438 @@
+"""
+cml.py -- types for communication between CML2 compiler and configurators.
+"""
+import sys, os, time
+
+version="2.3.0"
+
+class trit:
+    "A boolean or trit value"
+    type = "trit"
+    def __init__(self, value):
+        if isinstance(value, trit):
+            value = value.value
+        self.value = value
+    def __repr__(self):
+        return "nmy"[self.value]
+    def __nonzero__(self):
+        return self.value
+    def __hash__(self):
+        return self.value	# This magic needed to make trits valid dictionary keys
+    def __long__(self):
+        return self.value != 0
+    def __cmp__(self, other):
+        if not isinstance(other, trit):
+            if other is None:
+                return 1               # any trit > None
+            else:                       # Standard no-__cmp__ behavior=20
+                if id(self) < id(other):
+                    return -1
+                elif id(self) > id(other):
+                    return 1
+                else:
+                    return 0
+        else:
+            diff = self.value - other.value
+            if diff == 0:
+                return 0
+            else:
+                return diff / abs(diff)
+    def __and__(self, other):
+        return trit(min(self.value, other.value))
+    def __or__(self, other):
+        return trit(max(self.value, other.value))
+    def eval(self):
+        return self
+
+# Trit value constants
+y = trit(2)
+m = trit(1)
+n = trit(0)
+
+# This describes a configuration symbol...
+
+class ConfigSymbol:
+    "Compiled information about a menu or configuration symbol"
+    def __init__(self, name, type=None, default=None, prompt=None, file=None, lineno=None):
+        # Name, location, type, default.
+        self.name = name
+        self.file = file	# Definition location source file
+        self.lineno = lineno	# Definition location source line
+        self.type = type	# Type of symbol
+        self.range = None	# Range tuple
+        self.enum = None
+        self.discrete = None
+        self.helptext = None	# Help reference
+        self.default = default	# Value to use if none has been set.
+        # Hierarchy location
+        self.ancestors = []	# Ancestors of symbol (as set up by {})
+        self.dependents = []	# Dependents of symbol (as set up by {})
+        self.choicegroup = []	# Other symbols in a choicegroup.
+        self.menu = None	# Unique parent menu of this symbol
+        self.depth = 0		# Nesting depth in its subtree
+        # Auxiliary information
+        self.prompt = prompt	# Associated question string
+        self.properties = {}	# Associated properties
+        self.warnings = []	# Attached warndepend conditions
+        self.visibility = None	# Visibility predicate for symbol 
+        self.saveability = None	# Saveability predicate for symbol
+        self.items = []		# Menus only -- associated symbols
+        # Compiler never touches these
+        self.visits = 0   	# Number of visits so far
+        self.setcount = 0       # Should this symbol be written?
+        self.included = 0       # Seen in an inclusion?
+        self.inspected = 0      # Track menu inspections
+        self.iced = 0		# Is this frozen?
+
+    # Compute the value of a symbol 
+    def eval(self, debug=0):
+        "Value of symbol; passes back None if the symbol is unset."
+        if self.default is not None:
+            result = evaluate(self.default, debug)
+            # Handle casting.  This can matter in derivations
+            if self.type == "bool":
+                if isinstance(result, trit):
+                    result = trit(y.value * (result != n))
+                elif type(result) == type(0):
+                    result = trit(y.value * (result != 0))
+            elif self.type in ("decimal", "hexadecimal"):
+                if isinstance(result, trit):
+                    result = (result != n)
+            if debug > 3:
+                sys.stderr.write("...eval(%s)->%s (through default %s)\n" % \
+                                 (`self`, result, self.default))
+            return result
+        else:
+            if debug > 2:
+                sys.stderr.write("...eval(%s)->None (default empty)\n" % \
+                                 (`self`))
+            return None
+
+    # Access to help.
+    #
+    # This is the only place in the front end that knows about the CML1
+    # helpfile conventions.
+    def help(self):
+        "Is there help for the given symbol?"
+        if self.helptext:
+            return self.helptext
+        # Next five lines implement the CML1 convention for choices help;
+        # attach it to the first alternative.  But they check for help
+        # attached to the symbol itself first.
+        if self.menu and self.menu.type == "choices":
+            self = self.menu
+        if self.type == "choices" and not self.helptext:
+            self = self.items[0]
+        return self.helptext
+
+    def ancestor_of(self, entry):
+        "Test transitive completion of dependency."
+        # We don't also check visibility, because visibility guards can have
+        # disjunctions and it would be wrong to propagate up both branches.
+        if entry.menu:
+            searchpath = entry.ancestors + [entry.menu]
+        else:
+            searchpath = entry.ancestors
+        if self in searchpath:
+            return 1
+        for x in searchpath:
+            if self.ancestor_of(x):
+                return 1
+        return 0
+
+    # Predicates
+    def is_derived(self):
+        "Is this a derived symbol?"
+        return self.prompt is None
+    def is_logical(self):
+        "Is this a logical symbol?"
+        return self.type in ("bool", "trit")
+    def is_numeric(self):
+        "Is this a numeric symbol?"
+        return self.type in ("decimal", "hexadecimal")
+    def is_symbol(self):
+        "Is this a real symbol? (not a menu, not a choices, not a message)"
+        return self.type in ("bool","trit", "decimal","hexadecimal", "string")
+
+    # Property functions
+    def hasprop(self, prop):
+        return self.properties.has_key(prop)
+    def setprop(self, prop, val=1):
+        self.properties[prop] = val
+    def delprop(self, prop):
+        del self.properties[prop]
+    def showprops(self,):
+        return ", ".join(self.properties.keys())
+
+    def __repr__(self):
+        # So the right thing happens when we print symbols in expressions
+        return self.name
+    def dump(self):
+        if self.prompt:
+            res = "'%s'" % self.prompt
+        else:
+            res = "derived"
+        res += ", type %s," % self.type
+        if self.range:
+            res = res + " range %s," % (self.range,)
+        if self.menu:
+            res = res + " in %s," % (self.menu.name,)
+        if self.ancestors:
+            res = res + " under %s," % (self.ancestors,)
+        if self.dependents:
+            res = res + " over %s," % (self.dependents,)
+        if self.choicegroup:
+            res = res + " choicegroup %s," % (self.choicegroup,)
+        if self.visibility is not None:
+            res = res + " visibility %s," % (display_expression(self.visibility),)
+        if self.saveability is not None:
+            res = res + " saveability %s," % (display_expression(self.saveability),)
+        if self.default is not None:
+            res = res + " default %s," % (`self.default`,)
+        if self.items:
+            res = res + " items %s," % (self.items,)
+        if self.properties:
+            res = res + " props=%s," % (self.showprops(),)
+        if self.file and self.lineno is not None:
+            res = res + " where=%s:%d," % (self.file, self.lineno)
+        return res
+    def __str__(self):
+        # Note that requirements are not shown
+        res = "%s={" % (self.name)
+        res = res + self.dump()
+        return res[:-1] + "}"
+
+class Requirement:
+    "A requirement, together with a message to be shown if it's violated."
+    def __init__(self, wff, message, file, line):
+        self.predicate = wff
+        self.message = message
+        self.file = file
+        self.line = line
+
+    def str(self):
+        return display_expression(self.predicate)[1:-1]
+
+    def __repr__(self):
+        bindings = ""
+        for sym in flatten_expr(self.predicate):
+            bindings += "%s=%s, " % (sym.name, evaluate(sym))
+        bindings = bindings[:-2]
+        leader = '"%s", line %d: ' % (self.file, self.line)
+        if self.message:
+            return leader + self.message + " (" + bindings + ")"
+        else:
+            return leader + display_expression(self.predicate) + " (" + bindings + ")"
+
+# This describes an entire configuration.
+
+class CMLRulebase:
+    "A dictionary of ConfigSymbols and a set of constraints."
+    def __init__(self):
+        self.version = version
+        self.start = None		# Start menu name		
+        self.dictionary = {}		# Configuration symbols
+        self.prefix = ""		# Prepend this to all symbols
+        self.banner = ""		# ID the configuration domain
+        self.constraints = []		# All requirements
+        self.icon = None		# Icon for this rulebase
+        self.trit_tie = None		# Are trits enabled?
+        self.help_tie = None		# Help required for visibility?
+        self.expert_tie = None		# Expert flag for UI control
+        self.reduced = []
+    def __repr__(self):
+        res = "Start menu = %s\n" % (self.start,)
+        for k in self.dictionary.keys():
+            res = res + str(self.dictionary[k]) + "\n"
+        if self.prefix:
+            res = res + "Prefix:" + `self.prefix`
+        if self.banner:
+            res = res + "Banner:" + `self.banner`
+        return res
+    def optimize_constraint_access(self):
+        "Assign constraints to their associated symbols."
+        for entry in self.dictionary.values():
+            entry.constraints = []
+        for requirement in self.reduced:
+            for symbol in flatten_expr(requirement):
+                if not requirement in symbol.constraints:
+                    symbol.constraints.append(requirement)
+
+# These functions are used by both interpreter and compiler
+
+def evaluate(exp, debug=0):
+    "Compute current value of an expression."
+    def tritify(x):
+        if x:
+            return y
+        else:
+            return n
+    if debug > 2:
+        sys.stderr.write("evaluate(%s) begins...\n" % (`exp`,))
+    if type(exp) is type(()):
+        # Ternary operator
+        if exp[0] == '?':
+            guard = evaluate(exp[1], debug)
+            if guard:
+                return evaluate(exp[2], debug)
+            else:
+                return evaluate(exp[3], debug)
+        # Logical operations -- always trit-valued
+        elif exp[0] == 'not':
+            return tritify(not evaluate(exp[1], debug))
+        elif exp[0] == 'or':
+            return tritify(evaluate(exp[1], debug) or evaluate(exp[2], debug))
+        elif exp[0] == 'and':
+            return tritify(evaluate(exp[1], debug) and evaluate(exp[2], debug))
+        elif exp[0] == 'implies':
+            return tritify(not ((evaluate(exp[1], debug) and not evaluate(exp[2], debug))))
+        elif exp[0] == '==':
+            return tritify(evaluate(exp[1], debug) == evaluate(exp[2], debug))
+        elif exp[0] == '!=':
+            return tritify(evaluate(exp[1], debug) != evaluate(exp[2], debug))
+        elif exp[0] == '<=':
+            return tritify(evaluate(exp[1], debug) <= evaluate(exp[2], debug))
+        elif exp[0] == '>=':
+            return tritify(evaluate(exp[1], debug) >= evaluate(exp[2], debug))
+        elif exp[0] == '<':
+            return tritify(evaluate(exp[1], debug) < evaluate(exp[2], debug))
+        elif exp[0] == '>':
+            return tritify(evaluate(exp[1], debug) > evaluate(exp[2], debug))
+        # Arithmetic operations -- sometimes trit-valued
+        elif exp[0] == '|':
+            return evaluate(exp[1], debug) | evaluate(exp[2], debug)
+        elif exp[0] == '&':
+            return evaluate(exp[1], debug) & evaluate(exp[2], debug)
+        elif exp[0] == '$':
+            left = evaluate(exp[1])
+            right = evaluate(exp[2])
+            if left != right:
+                return n
+            else:
+                return left
+        elif exp[0] == '+':
+            return long(evaluate(exp[1],debug)) + long(evaluate(exp[2],debug))
+        elif exp[0] == '-':
+            return long(evaluate(exp[1],debug)) - long(evaluate(exp[2],debug))
+        elif exp[0] == '*':
+            return long(evaluate(exp[1],debug)) * long(evaluate(exp[2],debug))
+        else:
+            raise SyntaxError, "Unknown operation %s in expression" % (exp[0],)
+    elif isinstance(exp, trit) or type(exp) in (type(""), type(0), type(0L)):
+        if debug > 2:
+            sys.stderr.write("...evaluate(%s) returns itself\n" % (`exp`,))
+        return exp
+    elif isinstance(exp, ConfigSymbol):
+        result = exp.eval(debug)
+        if result:
+            return result
+        else:
+            return n
+    else:
+        raise ValueError,"unknown object %s %s in expression" % (exp,type(exp))
+
+def flatten_expr(node):
+    "Flatten an expression -- skips the operators"
+    if type(node) is type(()) or type(node) is type([]):
+       sublists = map(flatten_expr, node)
+       flattened = []
+       for item in sublists:
+           flattened = flattened + item
+       return flattened
+    elif isinstance(node, ConfigSymbol):
+        if node.is_derived():
+            return flatten_expr(node.default)
+        else:
+            return [node]
+    else:
+        return []
+
+def display_expression(exp):
+    "Display an expression in canonicalized infix form."
+    if type(exp) is type(()):
+        if exp[0] == "not":
+            return "not " + display_expression(exp[1])
+        elif exp[0] == '?':
+            return "(%s ? %s : %s)" % (display_expression(exp[1]), display_expression(exp[2]), display_expression(exp[3]))
+        else:
+            return "(%s %s %s)" % (display_expression(exp[1]), exp[0], display_expression(exp[2]))
+    elif isinstance(exp, ConfigSymbol):
+        return exp.name
+    else:
+        return `exp`
+
+class Baton:
+    "Ship progress indication to stdout."
+    def __init__(self, prompt, endmsg=None):
+        if os.isatty(1):
+            self.stream = sys.stdout
+        elif os.isatty(2):
+            self.stream = sys.stderr
+        else:
+            self.stream = None
+        if self.stream:
+            self.stream.write(prompt + "... \010")
+            self.stream.flush()
+        self.count = 0
+        self.endmsg = endmsg
+        self.time = time.time()
+        return
+
+    def twirl(self, ch=None):
+        if self.stream is None:
+            return
+        if ch:
+            self.stream.write(ch)
+        else:
+            self.stream.write("-/|\\"[self.count % 4])
+            self.stream.write("\010")
+        self.count = self.count + 1
+        self.stream.flush()
+        return
+
+    def end(self, msg=None):
+        if msg == None:
+            msg = self.endmsg
+        if self.stream:
+            self.stream.write("...(%2.2f sec) %s.\n" % (time.time() - self.time, msg))
+        return
+
+if __name__ == "__main__":
+    # Two classes without __cmp__
+    class A:
+        pass
+
+    class B:
+        pass
+
+    a = A()
+    b = B()
+
+    t0 = trit(0)
+    t1 = trit(1)
+    t2 = trit(2)
+
+    if not (t0 < t1 < t2 and t2 > t1 > t0) or t0 == t1 or t0 == t2 or t1 == t2:
+        print "trit compare failed"
+
+    if t0 < None:
+        print "a trit is less than None?  Comparison failed"
+
+    if None > t0:
+        print "None is greater than a trit?  Comparison failed"
+
+    if id(a) > id(b):
+        if a < b > a:
+            print "a/b comparison failed"
+    elif b < a > b:
+        print "a/b comparison failed"
+
+
+    # Simulate standard no-cmp() behavior for non-trits
+    if id(a) > id(t0):
+        if a < t0:
+            print "a/t0 comparison failed (id(a) greater)"
+    elif t0 < a:
+        print "a/t0 comparison failed"
+
+# cml.py ends here.