mirror of
https://github.com/drasko/codezero.git
synced 2026-01-12 19:03:15 +01:00
439 lines
15 KiB
Python
Executable File
439 lines
15 KiB
Python
Executable File
"""
|
|
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.
|