# HG changeset patch # User Paul Boddie # Date 1472935101 -7200 # Node ID ad44d74420568b05115ee31db151e17bac56bfdf # Parent 3245748d9431b43b722e562509c15ce1db21a4dc Moved result classes into a separate module, also removing Ellipsis as a predefined constant. diff -r 3245748d9431 -r ad44d7442056 common.py --- a/common.py Sat Sep 03 22:37:23 2016 +0200 +++ b/common.py Sat Sep 03 22:38:21 2016 +0200 @@ -23,6 +23,7 @@ from errors import * from os import listdir, makedirs, remove from os.path import exists, isdir, join, split +from results import ConstantValueRef, LiteralSequenceRef, NameRef import compiler class CommonOutput: @@ -228,6 +229,12 @@ def get_literal_reference(self, name, ref, items, cls): + """ + Return a literal reference for the given type 'name', literal 'ref', + node 'items' and employing the given 'cls' as the class of the returned + reference object. + """ + # Construct an invocation using the items as arguments. typename = "$L%s" % name @@ -465,6 +472,8 @@ self.next_iterator() self.process_structure_node(node) + # Node rewriting, without processing. + def convert_ifexp_node(self, n): """ @@ -580,6 +589,8 @@ compiler.ast.CallFunc( compiler.ast.Getattr(compiler.ast.Name(temp), "append"), [expr])) + # More node processing. + def process_literal_sequence_node(self, n, name, ref, cls): """ @@ -795,114 +806,6 @@ l.append(arg) return l -# Classes representing inspection and translation observations. - -class Result: - - "An abstract expression result." - - def is_name(self): - return False - def get_origin(self): - return None - -class NameRef(Result): - - "A reference to a name." - - def __init__(self, name, expr=None): - self.name = name - self.expr = expr - - def is_name(self): - return True - - def reference(self): - return None - - def final(self): - return None - - def __repr__(self): - return "NameRef(%r, %r)" % (self.name, self.expr) - -class LocalNameRef(NameRef): - - "A reference to a local name." - - def __init__(self, name, number): - NameRef.__init__(self, name) - self.number = number - - def __repr__(self): - return "LocalNameRef(%r, %r)" % (self.name, self.number) - -class ResolvedNameRef(NameRef): - - "A resolved name-based reference." - - def __init__(self, name, ref, expr=None): - NameRef.__init__(self, name, expr) - self.ref = ref - - def reference(self): - return self.ref - - def get_name(self): - return self.ref and self.ref.get_name() or None - - def get_origin(self): - return self.ref and self.ref.get_origin() or None - - def static(self): - return self.ref and self.ref.static() or None - - def final(self): - return self.ref and self.ref.final() or None - - def has_kind(self, kinds): - return self.ref and self.ref.has_kind(kinds) - - def __repr__(self): - return "ResolvedNameRef(%r, %r, %r)" % (self.name, self.ref, self.expr) - -class ConstantValueRef(ResolvedNameRef): - - "A constant reference representing a single literal value." - - def __init__(self, name, ref, value, number=None): - ResolvedNameRef.__init__(self, name, ref) - self.value = value - self.number = number - - def __repr__(self): - return "ConstantValueRef(%r, %r, %r, %r)" % (self.name, self.ref, self.value, self.number) - -class InstanceRef(Result): - - "An instance reference." - - def __init__(self, ref): - self.ref = ref - - def reference(self): - return self.ref - - def __repr__(self): - return "InstanceRef(%r)" % self.ref - -class LiteralSequenceRef(ResolvedNameRef): - - "A reference representing a sequence of values." - - def __init__(self, name, ref, node, items=None): - ResolvedNameRef.__init__(self, name, ref) - self.node = node - self.items = items - - def __repr__(self): - return "LiteralSequenceRef(%r, %r, %r, %r)" % (self.name, self.ref, self.node, self.items) - # Dictionary utilities. def init_item(d, key, fn): @@ -996,18 +899,31 @@ # Attribute chain decoding. def get_attrnames(attrnames): + + """ + Split the qualified attribute chain 'attrnames' into its components, + handling special attributes starting with "#" that indicate type + conformance. + """ + if attrnames.startswith("#"): return [attrnames] else: return attrnames.split(".") def get_attrname_from_location(location): + + """ + Extract the first attribute from the attribute names employed in a + 'location'. + """ + path, name, attrnames, access = location return get_attrnames(attrnames)[0] # Useful data. -predefined_constants = "Ellipsis", "False", "None", "NotImplemented", "True" +predefined_constants = "False", "None", "NotImplemented", "True" operator_functions = { diff -r 3245748d9431 -r ad44d7442056 results.py --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/results.py Sat Sep 03 22:38:21 2016 +0200 @@ -0,0 +1,158 @@ +#!/usr/bin/env python + +""" +Result abstractions. + +Copyright (C) 2016 Paul Boddie + +This program is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free Software +Foundation; either version 3 of the License, or (at your option) any later +version. + +This program is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +FOR A PARTICULAR PURPOSE. See the GNU General Public License for more +details. + +You should have received a copy of the GNU General Public License along with +this program. If not, see . +""" + +# Classes representing inspection and translation observations. + +class Result: + + "An abstract expression result." + + def is_name(self): + return False + def get_origin(self): + return None + +class AccessRef(Result): + + """ + A reference to an attribute access that is generally only returned from a + processed access for possible initialiser resolution for assignments. + """ + + def __init__(self, original_name, attrnames, number): + self.original_name = original_name + self.attrnames = attrnames + self.number = number + + def reference(self): + return None + + def __repr__(self): + return "AccessRef(%r, %r, %r)" % (self.original_name, self.attrnames, self.number) + +class InvocationRef(Result): + + "An invocation of a name reference." + + def __init__(self, name_ref): + self.name_ref = name_ref + + def __repr__(self): + return "InvocationRef(%r)" % self.name_ref + +class NameRef(Result): + + "A reference to a name." + + def __init__(self, name, expr=None): + self.name = name + self.expr = expr + + def is_name(self): + return True + + def reference(self): + return None + + def final(self): + return None + + def __repr__(self): + return "NameRef(%r, %r)" % (self.name, self.expr) + +class LocalNameRef(NameRef): + + "A reference to a local name." + + def __init__(self, name, number): + NameRef.__init__(self, name) + self.number = number + + def __repr__(self): + return "LocalNameRef(%r, %r)" % (self.name, self.number) + +class ResolvedNameRef(NameRef): + + "A resolved name-based reference." + + def __init__(self, name, ref, expr=None): + NameRef.__init__(self, name, expr) + self.ref = ref + + def reference(self): + return self.ref + + def get_name(self): + return self.ref and self.ref.get_name() or None + + def get_origin(self): + return self.ref and self.ref.get_origin() or None + + def static(self): + return self.ref and self.ref.static() or None + + def final(self): + return self.ref and self.ref.final() or None + + def has_kind(self, kinds): + return self.ref and self.ref.has_kind(kinds) + + def __repr__(self): + return "ResolvedNameRef(%r, %r, %r)" % (self.name, self.ref, self.expr) + +class ConstantValueRef(ResolvedNameRef): + + "A constant reference representing a single literal value." + + def __init__(self, name, ref, value, number=None): + ResolvedNameRef.__init__(self, name, ref) + self.value = value + self.number = number + + def __repr__(self): + return "ConstantValueRef(%r, %r, %r, %r)" % (self.name, self.ref, self.value, self.number) + +class InstanceRef(Result): + + "An instance reference." + + def __init__(self, ref): + self.ref = ref + + def reference(self): + return self.ref + + def __repr__(self): + return "InstanceRef(%r)" % self.ref + +class LiteralSequenceRef(ResolvedNameRef): + + "A reference representing a sequence of values." + + def __init__(self, name, ref, node, items=None): + ResolvedNameRef.__init__(self, name, ref) + self.node = node + self.items = items + + def __repr__(self): + return "LiteralSequenceRef(%r, %r, %r, %r)" % (self.name, self.ref, self.node, self.items) + +# vim: tabstop=4 expandtab shiftwidth=4