def __init__(self, obj, prop):
if isstring(obj): obj = Object(obj)
assert isinstance(obj, Object), "got " + obj.__class__.__name__
if isstring(prop): prop = Identifier(prop)
assert isinstance(prop, Identifier)
super(StructProperty, self).__init__({"obj" : obj, "prop": prop})
self.obj = obj
self.prop = prop
def __init__(self, obj, prop, type=None):
if isstring(obj): obj = Object(obj)
assert isinstance(obj, Object), "got " + obj.__class__.__name__
if isstring(prop): prop = Identifier(prop)
assert isinstance(prop, Identifier)
if type is None: type = VoidType()
assert isinstance(type, Type)
super(ObjectProperty, self).__init__({"obj" : obj, "prop": prop})
self.obj = obj
self.prop = prop
self.type = type
def __init__(self, name, type):
if isstring(name): name = Identifier(name)
assert isinstance(name, Identifier)
assert isinstance(type, Type), "expected Type but got " + type.__class__.__name__
super(Property, self).__init__({"name": name, "type": type})
self.name = name
self.type = type
def __init__(self, operand, expression):
if isstring(operand): operand = SimpleVariable(operand)
assert isinstance(operand, Variable)
assert isinstance(expression, Expression)
Statement.__init__(self, {"operand": operand, "expression": expression})
self.operand = operand
self.expression = expression
def __init__(self, id, type):
if isstring(id): id = Identifier(id)
assert isinstance(id, Identifier)
assert isinstance(type, Type), "got " + type.__class__.__name__
super(VariableDecl, self).__init__({"id":id, "type":type})
self.id = id
self.type = type
def __init__(self, id, value, type=None):
# name
if isstring(id): id = Identifier(id)
assert isinstance(id, Identifier), "Name should be an identifier, not" + \
id.__class__.__name__
# TODO: add some value-checking ? (to avoid havoc)
if isstring(value): value = Identifier(value)
if type is None: type = VoidType()
assert isinstance(type, Type), "Type should be a Type, not " + \
type.__class__.__name__
super(Constant, self).__init__({"id": id, "value": value, "type": type})
self.id = id
self.value = value
self.type = type
def __init__(self, function, arguments=[], type=None):
if isstring(function): function = Identifier(function)
assert isinstance(function, Identifier)
if type is None: type = VoidType()
assert isinstance(type, Type), "but got " + type.__class__.__name__
super(FunctionCall, self).__init__({"function": function}, arguments)
self.function = function
self.type = type
def __init__(self, comp, expression=None):
if isstring(comp): comp = Comparator(comp)
assert isinstance(comp, Comparator), \
"Expected Comparator but got " + comp.__class__.__module__ + ":" + comp.__class__.__name__
assert expression == None or isinstance(expression, Expression)
super(Match, self).__init__({"comp": comp, "exp": expression})
self.comp = comp
self.expression = expression
def __init__(self, id, type=None):
if isstring(id): id = Identifier(id)
assert isinstance(id, Identifier)
if type is None: type = VoidType()
assert isinstance(type, Type)
super(Object, self).__init__({"id": id, "type": type})
self.id = id
self.type = type
def __init__(self, obj, method, arguments=[], type=None):
assert isinstance(obj, Object) or isinstance(obj, ObjectProperty), \
"Expected Object(Property), but got " + obj.__class__.__name__
if isstring(method): method = Identifier(method)
if type is None: type = VoidType()
assert isinstance(type, Type), "but got " + type.__class__.__name__
assert isinstance(method, Identifier)
super(MethodCall, self).__init__({"obj": obj, "method": method}, arguments)
self.obj = obj
self.method = method
self.type = type
def __init__(self, string, *args):
# string
if isstring(string): string = StringLiteral(string)
assert isinstance(string, StringLiteral)
# TODO: assert args to be expressions
super(Print, self).__init__({"string": string, "args": args})
self.string = string
self.args = args
def __init__(self, id, type=None, default=None):
# name
if isstring(id): id = Identifier(id)
assert isinstance(id, Identifier)
# type
if type is None: type = VoidType()
assert isinstance(type, Type)
assert default == None or isinstance(default, Expression)
super(Parameter, self).__init__({"id": id, "type": type, "default": default})
self.id = id
self.type = type
self.default = default
def __init__(self, name, type=None, params=[]):
# name
assert not name is None, "A function needs at least a name." # TODO: extend
if isstring(name): name = Identifier(name)
assert isinstance(name, Identifier), "Name should be an identifier, not" + \
name.__class__.__name__
# type
if type is None: type = VoidType()
assert isinstance(type, Type), "Return-type should be a Type, not " + \
type.__class__.__name__
# params
if isinstance(params, list): params = TypedList(Parameter, params)
super(Function, self).__init__({"id":name, "type":type, "params": params})
self.id = name
self.type = type
self.params = params
def visit_MatchExp(self, exp):
return (exp.operator.accept(self) if isstring(exp.operator) else exp.operator.accept(self)) + \
((" " + exp.operand.accept(self)) if exp.operand != None else "")
def visit_MatchExp(self, exp):
return (exp.operator.accept(self) if isstring(exp.operator) else exp.operator.accept(self)) + \
((" " + exp.operand.accept(self)) if exp.operand != None else "")
def process(self, obj):
# IDENTIFIERS
if isinstance(obj, Identifier):
return self.dot.node(obj.name, {"color":"seagreen"})
# CLASSES
if inspect.isclass(obj):
options = {"color":"springgreen"} if "semantic.model" in obj.__module__ else {}
node = self.dot.node(obj.__name__, options)
return node
# A SIMPLE TYPE
if isstring(obj) or isinstance(obj, int) or isinstance(obj, float) or \
isinstance(obj, bool):
return self.dot.node(str(obj))
# UNKNOWN TYPE
if isinstance(obj, UnknownType):
return self.dot.node(obj.__class__.__name__, {"color":"coral"})
# ANY TYPE
if isinstance(obj, AnyType):
return self.dot.node(obj.__class__.__name__, {"color":"limegreen"})
# ANYTHING EXP
if isinstance(obj, AnythingExp):
return self.dot.node(obj.__class__.__name__, {"color":"green"})
# TYPES
if isinstance(obj, TypeExp) and not isinstance(obj, ComplexType):
return self.dot.node(obj.__class__.__name__, {"color":"limegreen"})
# RECURSION & LOOP DETECTION
if str(obj.__repr__) in self.processed:
return self.dot.node("dict" if isinstance(obj, dict) else str(obj),
{"color":"lightblue"})
self.processed.append(str(obj.__repr__))
# ITERATABLES
# SIMPLE DICT
if isinstance(obj, dict):
node = self.dot.node(obj.__class__.__name__)
for key, value in obj.items():
if not value is None:
self.dot.vertex(node, self.process(value), {"label":key})
# SIMPLE LIST
elif isinstance(obj, list):
node = self.dot.node(obj.__class__.__name__)
for value in obj:
if not value is None:
self.dot.vertex(node, self.process(value))
# OBJECT
else:
options = {"color":"limegreen"} if isinstance(obj, ComplexType) else \
{"color":"green"} if "foo_lang.semantic" in obj.__module__ else {}
node = self.dot.node(obj.__class__.__name__, options)
# if the obj supports the .type property, add it as such
if hasattr(obj, "type") and not isinstance(obj, TimestampType):
subnode = self.process(obj.type)
self.dot.vertex(node, subnode, {"label": "type"})
# manual exception to allow modules to be processed in such a way that
# domains are processed sooner than functions, to make sure that types
# defined in domains are added in detail and all other instances are shown
# as references
if isinstance(obj, Module):
items = [ ["identifier", obj.identifier],
["constants", obj.constants],
["externals", obj.externals],
["domains", obj.domains],
["functions", obj.functions],
["executions", obj.executions]
]
elif isinstance(obj, Domain):
items = [
["extensions", obj.extensions],
["node_t", obj.node_t],
["payload_t", obj.payload_t]
]
else:
items = obj.__dict__.items()
for key, value in items:
if key not in ["_type", "type"] and not value is None:
# SCOPE
if isinstance(value, Scope):
subnode = self.dot.node(value.__class__.__name__, {"color":"lightblue"})
else:
subnode = self.process(value)
self.dot.vertex(node, subnode, {"label":key})
return node
def __init__(self, name, properties=[]):
if isstring(name): name = Identifier(name)
assert isinstance(name, Identifier)
super(UnionType, self).__init__({"name":name})
self.name = name
def __init__(self, name):
assert isstring(name)
super(NamedType, self).__init__({"name": name})
self.name = name
def __init__(self, id):
if isstring(id): id = Identifier(id)
assert isinstance(id, Identifier)
super(AtomLiteral, self).__init__({"name": id.name})
self.id = id
def __init__(self, comment):
assert isstring(comment)
super(Comment, self).__init__({"comment": comment})
self.comment = comment
def __init__(self, id, info=None):
if isstring(id): id = Identifier(id)
assert isinstance(id, Identifier)
super(SimpleVariable, self).__init__({"id": id, "info": info})
self.id = id
self.info = info
def __init__(self, id, index):
if isstring(id): id = Identifier(id)
assert isinstance(id, Identifier) or isinstance(id, Variable)
super(ListVariable, self).__init__({"id": id, "index": index})
self.id = id
self.index = index
def process(self, obj):
# IDENTIFIERS
if isinstance(obj, Identifier):
return self.dot.node(obj.name, {"color": "seagreen"})
# CLASSES
if inspect.isclass(obj):
options = {
"color": "springgreen"
} if "semantic.model" in obj.__module__ else {}
node = self.dot.node(obj.__name__, options)
return node
# A SIMPLE TYPE
if isstring(obj) or isinstance(obj, int) or isinstance(obj, float) or \
isinstance(obj, bool):
return self.dot.node(str(obj))
# UNKNOWN TYPE
if isinstance(obj, UnknownType):
return self.dot.node(obj.__class__.__name__, {"color": "coral"})
# ANY TYPE
if isinstance(obj, AnyType):
return self.dot.node(obj.__class__.__name__,
{"color": "limegreen"})
# ANYTHING EXP
if isinstance(obj, AnythingExp):
return self.dot.node(obj.__class__.__name__, {"color": "green"})
# TYPES
if isinstance(obj, TypeExp) and not isinstance(obj, ComplexType):
return self.dot.node(obj.__class__.__name__,
{"color": "limegreen"})
# RECURSION & LOOP DETECTION
if str(obj.__repr__) in self.processed:
return self.dot.node("dict" if isinstance(obj, dict) else str(obj),
{"color": "lightblue"})
self.processed.append(str(obj.__repr__))
# ITERATABLES
# SIMPLE DICT
if isinstance(obj, dict):
node = self.dot.node(obj.__class__.__name__)
for key, value in obj.items():
if not value is None:
self.dot.vertex(node, self.process(value), {"label": key})
# SIMPLE LIST
elif isinstance(obj, list):
node = self.dot.node(obj.__class__.__name__)
for value in obj:
if not value is None:
self.dot.vertex(node, self.process(value))
# OBJECT
else:
options = {"color":"limegreen"} if isinstance(obj, ComplexType) else \
{"color":"green"} if "foo_lang.semantic" in obj.__module__ else {}
node = self.dot.node(obj.__class__.__name__, options)
# if the obj supports the .type property, add it as such
if hasattr(obj, "type") and not isinstance(obj, TimestampType):
subnode = self.process(obj.type)
self.dot.vertex(node, subnode, {"label": "type"})
# manual exception to allow modules to be processed in such a way that
# domains are processed sooner than functions, to make sure that types
# defined in domains are added in detail and all other instances are shown
# as references
if isinstance(obj, Module):
items = [["identifier", obj.identifier],
["constants", obj.constants],
["externals",
obj.externals], ["domains", obj.domains],
["functions", obj.functions],
["executions", obj.executions]]
elif isinstance(obj, Domain):
items = [["extensions", obj.extensions],
["node_t", obj.node_t], ["payload_t", obj.payload_t]]
else:
items = obj.__dict__.items()
for key, value in items:
if key not in ["_type", "type"] and not value is None:
# SCOPE
if isinstance(value, Scope):
subnode = self.dot.node(value.__class__.__name__,
{"color": "lightblue"})
else:
subnode = self.process(value)
self.dot.vertex(node, subnode, {"label": key})
return node