def str_as_atr(s):
if s == '_':
return []
atr = []
i = 0
while i < len(s):
v = s[i]
if i + 1 < len(s) and s[i+1].isdigit():
n = 0
i = i + 1
while i < len(s) and s[i].isdigit():
n = n * 10 + int(s[i])
i += 1
else:
i += 1
n = 1
for j in range(n):
atr.append(v)
return atr
def atr_as_str(atr):
if not atr:
return '_'
prefl = []
prestr = ''.join([str(x) for x in atr])
i = 0
while i < len(prestr):
c = prestr[i]
j = i+1
while j < len(prestr) and prestr[j] == c:
j += 1
if j - i > 2:
prefl.append(c)
prefl.append(str(j-i))
else:
while i < j:
prefl.append(c)
i += 1
i = j
return ''.join(prefl)
def str_as_ixl(s):
return [ord(ch)-ord('a') for ch in str_as_atr(s)]
def ixl_as_str(ixl):
return atr_as_str([chr(ix + ord('a')) for ix in ixl])
class Paths:
def __init__(self, mod, rp, key, extended=True, andsets=(), variant=2):
self.mod = mod
self._hiding_tag_ = mod._hiding_tag_
self.key = key
self.rp = rp
self.extended = extended
self.srcrow = rp.get_row(self.key)
self.variant = variant
self.andsetbyname = {}
row = self.srcrow
while row is not None:
self.andsetbyname[row.ixlstr] = mod.Use.Anything
row = row.parent
if isinstance(andsets, dict):
self.andsetbyname.update(andsets)
elif isinstance(andsets, (tuple, list)):
row = self.srcrow
for i, s in enumerate(andsets):
if row is None:
raise ValueError('andsets argument is too long')
if s is not None:
self.andsetbyname[row.ixlstr] = s
row = row.parent
else:
raise TypeError('andsets argument must be dict, tuple, or list')
mod.OutputHandling.setup_printing(
self,
stop_only_when_told=variant >= 2)
def get_str_of_path_component_singleton(self, set):
return set.brief.lstrip('<1 ').rstrip('>')
def source_to_target_info(self):
src = 'Source'
tgt = 'Target'
via = 'Via'
row = self.srcrow
indent = 0
while row is not None:
if row.parent is None:
a = tgt
elif row is srcrow:
a = src
else:
a = via
a = ' '*indent + a
name = row.ixlstr
a = a + ' ' + ' '*(8+srcrow.depth*indinc -
len(name)-len(a)) + name + ': '
yield a+row.getsummary(mod.line_length-len(a))
row = row.parent
indent += indinc
def _oh_get_label(self):
return 'Paths from source %r to target %r.' % (self.srcrow.ixlstr, '_')
def _oh_get_line_iter(self):
return getattr(self, 'get_line_iter_%s' % (self.variant,))()
def _oh_get_more_state_msg(self, startindex, lastindex):
return ''
def get_line_iter_1(self):
# Original variant indenting from left to right
mod = self.mod
srcrow = self.srcrow
srcset = srcrow.set
indinc = 2
if srcrow.depth >= 10:
indinc = 1
def genlines(row, ks, indent=0):
par = row.parent
for key, i, set in ks:
sidx = '%s[%d]' % (row.ixlstr, i)
if self.extended:
strsing = self.get_str_of_path_component_singleton(set)
else:
strsing = ''
vline = '%s %s %s %s' % (
key,
' '*(40-len(key) - len(sidx)),
sidx,
strsing
)
yield vline
if par is None:
continue
def get_nks(key, set):
parset = set.referents & par.set
for i, p in enumerate(parset.byid.parts):
rels = mod.Path.relations(set.theone, p.theone)
for rel in rels:
if rel is mod.Path.identity:
continue
if rel is mod.Path.norelation:
k = '??'
else:
k = str(rel) % ''
k = ' '*(indent+indinc)+k
yield k, i, p
for line in genlines(par, get_nks(key, set), indent+indinc):
yield line
def get_ks():
for i, s in enumerate(srcset.byid.parts):
k = '[%d] ' % i
k = k + (' -'*20)[:36-len(k)-srcrow.depth]
yield k, i, s
for line in genlines(srcrow, get_ks()):
yield line
return
def get_line_iter_2(self):
# Newer variant
mod = self.mod
srcrow = self.srcrow
indinc = 1
if srcrow.depth >= 10:
indinc = 1
lno = [0]
seen = {}
indir = 1
if indir == 1:
max_ixlstr_len = 0
max_str_len_set = 0
row = srcrow
while row:
if len(row.ixlstr) > max_ixlstr_len:
max_ixlstr_len = len(row.ixlstr)
if len(str(len(row.set.nodes))) > max_str_len_set:
max_str_len_set = len(str(len(row.set.nodes)))
row = row.parent
def genlines(row, part, idx):
seen[part.nodes, row.depth] = lno[0]
sidx = row.ixlstr
idxs = '[%d]' % idx
if indir < 0:
indent = (row.depth)*indinc
sidx = '%s%s%s' % (
sidx, ' '*(6+indent-len(sidx)-len(idxs)), idxs)
if row.parent is None:
sidx += ' == %s' % part.brief
else:
#idxs = ('[%.'+str(max_str_len_set)+'d]')%idx
sidx = '%s%s%s' % (sidx,
' '*(3+max_str_len_set +
max_ixlstr_len-len(sidx)-len(idxs)),
idxs)
sidx += ' ' * (srcrow.depth + 1 - row.depth)
if row.parent is not None:
sidx += '@'
else:
sidx += '= %s' % part.brief
if row.parent is None:
#vline += ' == %s'%self.get_str_of_path_component_singleton(part)
vline = '%2s: %s' % (lno[0], sidx)
lno[0] += 1
yield ('STOP_AFTER', vline)
return
referents = part.referents & row.parent.set & self.andsetbyname[row.parent.ixlstr]
relations = mod.Path.relations
iso = mod.Use.iso
s = part.theone
t = [(relations(s, p.theone), p.by(referents.er), i)
for (i, p) in enumerate(referents.byid.parts)]
for (rels, p, i) in t:
relstrings = []
for rel in rels:
if rel is mod.Path.identity:
continue
if rel is mod.Path.norelation:
k = '??'
else:
k = str(rel) % ''
relstrings.append(k)
relsstr = ' / '.join(relstrings)
seenlno = seen.get((p.nodes, row.parent.depth))
vline = '%2s: %s' % (lno[0], sidx)
lno[0] += 1
if seenlno is not None:
relsstr += ' -> #%d' % seenlno
yield ('STOP_AFTER', vline + ' ' + relsstr)
else:
yield vline + ' ' + relsstr
for line in genlines(row.parent, p, i):
yield line
for i, p in enumerate((srcrow.set & self.andsetbyname[srcrow.ixlstr]).byid.parts):
for line in genlines(srcrow, p, i):
yield line
class RefPatIter:
def __init__(self, rp, start=0):
self.rp = rp
self._hiding_tag_ = rp._hiding_tag_
self.ix = start
def __iter__(self):
return self
def __next__(self):
try:
x = self.rp[self.ix]
except IndexError:
raise StopIteration
self.ix += 1
return x
class RefPatRow:
def __init__(self, rp, kindset, seenline, ixl, parent):
self.rp = rp
self._hiding_tag_ = rp._hiding_tag_
self.kindset = kindset
self.kind, self.set = kindset
assert self.set <= self.kind
self.seenline = seenline
self.ixl = ixl[:]
self.parent = parent
if parent is not None:
self.depth = parent.depth + 1
else:
self.depth = 0
self.index = 0
self.maxdepth = rp.depth
self.max_str_len = rp.mod.line_length
self.ixlstr = ixl_as_str(ixl)
self.isready = 0
self.children = []
def __str__(self):
prestr = '%2d: %s ' % (self.index, self.ixlstr)
if self.index & 1:
fillpat = ' ' * 100
else:
fillpat = '-'*100
lps = len(prestr)
fill = fillpat[lps:9+self.depth]
if self.seenline:
ref = '[^ %s]' % self.seenline.index
elif self.isroot:
ref = '[R]'
elif self.depth > 0 and self.set <= self.rp.stopkind:
ref = '[S]'
elif self.depth < self.maxdepth:
ref = '[-]'
else:
ref = '[+]'
prefix = '%s%s %s ' % (prestr, fill, ref)
return '%s%s' % (prefix, self.getsummary(self.max_str_len-len(prefix)))
def getchild(self, ix):
while ix >= len(self.children) and not self.isready:
self.rp.generate(len(self.rp.lines))
return self.children[ix]
def getsummary(self, max_len):
kind, set = self.kind, self.set
summary = set.fam.get_str_refpat(set, kind, max_len)
return summary
class ReferencePattern:
__doc__ = '<Help Text'
help = """\
Methods
"""
def __init__(self, mod, set, depth, er, relimg, bf, stopkind, nocyc):
self.mod = mod
self._hiding_tag_ = mod._hiding_tag_
self.View = mod.View
self.set = set
self.depth = depth
self.er = er
self.bf = bf
self.stopkind = stopkind
self.nocyc = nocyc
self.is_initialized = 0
self.totcount = set.count
self.totsize = set.indisize
self.kind = set.kind
self.kindset = (self.kind, self.set)
self.relimg = relimg
self.top = self
mod.OutputHandling.setup_printing(self)
self.View.referrers_add_target(self)
self.reset_nogc()
self.is_initialized = 1
def __getattr__(self, s):
if not self.is_initialized:
raise AttributeError(s)
try:
return getattr(self.__class__, s)
except AttributeError:
pass
try:
row = self.get_row_named(s)
except ValueError:
raise AttributeError(s)
return row.set
def __getitem__(self, ix):
return self.get_row_indexed(ix).set
def __iter__(self, start=0):
return RefPatIter(self, start)
def __len__(self):
self.generate()
return len(self.lines)
def _oh_get_label(self):
return 'Reference Pattern by <' + self.er.classifier.get_byname() + '>.'
def _oh_get_more_state_msg(self, startindex, lastindex):
if self.isfullygenerated:
msg = '%d more lines. ' % (len(self.lines) - 1-lastindex,)
else:
msg = ''
return msg
def _oh_get_line_iter(self):
it = self.iterlines(0)
for el in it:
yield str(el)
def generate(self, ix=None):
while ix is None or ix < 0 or ix >= len(self.lines):
try:
self.lines.append(next(self.lg))
except StopIteration:
self.isfullygenerated = 1
return
self.lines[-1].index = len(self.lines) - 1
def get_row(self, key):
try:
[][key]
except TypeError:
return self.get_row_named(key)
except IndexError:
return self.get_row_indexed(key)
def get_row_indexed(self, ix):
self.generate(ix)
return self.lines[ix]
def get_row_named(self, name):
row = self.get_row_indexed(0)
for ix in str_as_ixl(name):
try:
row = row.getchild(ix)
except IndexError:
raise ValueError(
'Reference pattern has no row named %r' % name)
return row
def iterlines(self, start=None):
if start is None:
start = 0
while 1:
try:
yield self.get_row_indexed(start)
except IndexError:
return
start += 1
def linegenerator(self, xxx_todo_changeme, ixl, parent=None):
(kind, set) = xxx_todo_changeme
seenline = self.seensets.get(set.nodes)
ixl = list(ixl)
line = RefPatRow(self, (kind, set), seenline=seenline,
ixl=ixl, parent=parent)
children = self.get_children(line)
line.isroot = not children
if seenline is None:
self.seensets[set.nodes] = line
if parent is not None:
parent.children.append(line)
yield line
depth = line.depth
if (not seenline and depth < self.depth and
(depth == 0 or not (set <= self.stopkind))):
for i, cs in enumerate(children):
ixl.append(i)
for rl in self.linegenerator(cs, ixl, line):
yield rl
ixl.pop()
line.isready = 1
def get_children(self, line):
(kind, set) = line.kindset
chset = self.relimg(set)
if self.nocyc:
while line is not None:
chset -= line.set
line = line.parent
return [(row.kind, row.set)
for row in self.get_partition(chset, self.er).get_rows()]
def get_partition(self, set, er):
p = self.mod.Part.partition(set, er)
return p
def paths(self, key, **kwds):
return Paths(self.mod, self, key, **kwds)
def reset(self):
self.reset_nogc()
self.printer.reset()
self.mod._root.gc.collect()
def reset_nogc(self):
self.isfullygenerated = 0
self.seensets = {}
self.lines = []
self.lg = self.linegenerator(self.kindset, [])
self.lastindex = None
class _GLUECLAMP_:
_preload_ = ('_hiding_tag_',)
depth = 7
line_length = 80
_uniset_exports = ('rp',)
_chgable_ = ('er',
'depth',
'line_length',
)
# 'module imports'
_imports_ = (
'_parent:OutputHandling',
'_parent:Part',
'_parent:Path',
'_parent:UniSet',
'_parent:Use',
'_parent:View',
'_parent.View:_hiding_tag_',
)
#
def _get_er(self): return self.Use.Clodo
def _get_stopkind(self):
hp = self.Use
return (
hp.Type.Module |
hp.Type.Type |
hp.Type.Module.dictof |
hp.Type.Type.dictof |
hp.Type.Code |
hp.Type.Frame
)
def rp(self, X, depth=None, er=None, imdom=0, bf=0, src=None, stopkind=None,
nocyc=False, ref=None):
"""rp(X, depth=None, er=None, imdom=0, bf=0, src=None, stopkind=None, nocyc=False, ref=None)
Reference pattern forming.
Arguments
X Set of objects for which a reference pattern is sought.
depth The depth to which the pattern will be generated. The
default is taken from depth of this module.
er The equivalence relation to partition the referrers. The default
is Clodo.
imdom If true, the immediate dominators will be used instead
of the referrers. This will take longer time to calculate,
but may be useful to reduce the complexity of the reference
pattern.
bf If true, the pattern will be printed in breadth-first
order instead of depth-first. (Experimental.)
src If specified, an alternative reference source instead
of the default root.
stopkind
nocyc
ref
Description
Return a reference pattern object based on the objects in the set X.
The reference pattern object is of class ReferencePattern. It is
described in XXX.
"""
if depth is None:
depth = self.depth
X = self.UniSet.idset_adapt(X)
if src is not None:
# Creates an entire new guppy tree
# Mostly for testing purposes -
# can likely cause type problems generally
src = self.UniSet.idset_adapt(src)
self = self._root.guppy.Root().guppy.heapy.RefPat
self.View.root = tuple(src.nodes)
X = self.Use.idset(X.nodes)
if er is None:
er = self.er # NEEDS to be loaded after new Classifier created
if imdom:
def relimg(X): return X.imdom
elif ref is not None:
if ref == 'gc':
def relimg(X): return X.referrers_gc
elif ref == 'gcx':
relimg = (lambda x: x.referrers_gc
- self._root.guppy.sets.ImmNodeSet
- self._parent.heapyc.NodeGraph
- self.View.ObservationList)
elif ref == 'imdom':
def relimg(X): return X.imdom
elif callable(ref):
relimg = ref
else:
raise ValueError(
"ref should be 'gc', 'gcx', 'imdom', or a callable")
else:
def relimg(X): return X.referrers
if stopkind is None:
stopkind = self.stopkind
rp = ReferencePattern(self, X, depth, er, relimg, bf, stopkind, nocyc)
return rp
|