blob: a99d3715c72ca53543c51eca797b73d84d597b86 [file] [log] [blame]
# Copyright (c) 2004-2006 The Regents of The University of Michigan
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met: redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer;
# redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution;
# neither the name of the copyright holders nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
# Authors: Steve Reinhardt
# Nathan Binkert
#####################################################################
#
# Proxy object support.
#
#####################################################################
import copy
class BaseProxy(object):
def __init__(self, search_self, search_up):
self._search_self = search_self
self._search_up = search_up
self._multiplier = None
def __str__(self):
if self._search_self and not self._search_up:
s = 'Self'
elif not self._search_self and self._search_up:
s = 'Parent'
else:
s = 'ConfusedProxy'
return s + '.' + self.path()
def __setattr__(self, attr, value):
if not attr.startswith('_'):
raise AttributeError, \
"cannot set attribute '%s' on proxy object" % attr
super(BaseProxy, self).__setattr__(attr, value)
# support multiplying proxies by constants
def __mul__(self, other):
if not isinstance(other, (int, long, float)):
raise TypeError, "Proxy multiplier must be integer"
if self._multiplier == None:
self._multiplier = other
else:
# support chained multipliers
self._multiplier *= other
return self
__rmul__ = __mul__
def _mulcheck(self, result):
if self._multiplier == None:
return result
return result * self._multiplier
def unproxy(self, base):
obj = base
done = False
if self._search_self:
result, done = self.find(obj)
if self._search_up:
# Search up the tree but mark ourself
# as visited to avoid a self-reference
self._visited = True
obj._visited = True
while not done:
obj = obj._parent
if not obj:
break
result, done = self.find(obj)
self._visited = False
base._visited = False
if not done:
raise AttributeError, \
"Can't resolve proxy '%s' of type '%s' from '%s'" % \
(self.path(), self._pdesc.ptype_str, base.path())
if isinstance(result, BaseProxy):
if result == self:
raise RuntimeError, "Cycle in unproxy"
result = result.unproxy(obj)
return self._mulcheck(result)
def getindex(obj, index):
if index == None:
return obj
try:
obj = obj[index]
except TypeError:
if index != 0:
raise
# if index is 0 and item is not subscriptable, just
# use item itself (so cpu[0] works on uniprocessors)
return obj
getindex = staticmethod(getindex)
# This method should be called once the proxy is assigned to a
# particular parameter or port to set the expected type of the
# resolved proxy
def set_param_desc(self, pdesc):
self._pdesc = pdesc
class AttrProxy(BaseProxy):
def __init__(self, search_self, search_up, attr):
super(AttrProxy, self).__init__(search_self, search_up)
self._attr = attr
self._modifiers = []
def __getattr__(self, attr):
# python uses __bases__ internally for inheritance
if attr.startswith('_'):
return super(AttrProxy, self).__getattr__(self, attr)
if hasattr(self, '_pdesc'):
raise AttributeError, "Attribute reference on bound proxy"
# Return a copy of self rather than modifying self in place
# since self could be an indirect reference via a variable or
# parameter
new_self = copy.deepcopy(self)
new_self._modifiers.append(attr)
return new_self
# support indexing on proxies (e.g., Self.cpu[0])
def __getitem__(self, key):
if not isinstance(key, int):
raise TypeError, "Proxy object requires integer index"
if hasattr(self, '_pdesc'):
raise AttributeError, "Index operation on bound proxy"
new_self = copy.deepcopy(self)
new_self._modifiers.append(key)
return new_self
def find(self, obj):
try:
val = getattr(obj, self._attr)
visited = False
if hasattr(val, '_visited'):
visited = getattr(val, '_visited')
if not visited:
# for any additional unproxying to be done, pass the
# current, rather than the original object so that proxy
# has the right context
obj = val
else:
return None, False
except:
return None, False
while isproxy(val):
val = val.unproxy(obj)
for m in self._modifiers:
if isinstance(m, str):
val = getattr(val, m)
elif isinstance(m, int):
val = val[m]
else:
assert("Item must be string or integer")
while isproxy(val):
val = val.unproxy(obj)
return val, True
def path(self):
p = self._attr
for m in self._modifiers:
if isinstance(m, str):
p += '.%s' % m
elif isinstance(m, int):
p += '[%d]' % m
else:
assert("Item must be string or integer")
return p
class AnyProxy(BaseProxy):
def find(self, obj):
return obj.find_any(self._pdesc.ptype)
def path(self):
return 'any'
# The AllProxy traverses the entire sub-tree (not only the children)
# and adds all objects of a specific type
class AllProxy(BaseProxy):
def find(self, obj):
return obj.find_all(self._pdesc.ptype)
def path(self):
return 'all'
def isproxy(obj):
if isinstance(obj, (BaseProxy, params.EthernetAddr)):
return True
elif isinstance(obj, (list, tuple)):
for v in obj:
if isproxy(v):
return True
return False
class ProxyFactory(object):
def __init__(self, search_self, search_up):
self.search_self = search_self
self.search_up = search_up
def __getattr__(self, attr):
if attr == 'any':
return AnyProxy(self.search_self, self.search_up)
elif attr == 'all':
if self.search_up:
assert("Parant.all is not supported")
return AllProxy(self.search_self, self.search_up)
else:
return AttrProxy(self.search_self, self.search_up, attr)
# global objects for handling proxies
Parent = ProxyFactory(search_self = False, search_up = True)
Self = ProxyFactory(search_self = True, search_up = False)
# limit exports on 'from proxy import *'
__all__ = ['Parent', 'Self']
# see comment on imports at end of __init__.py.
import params # for EthernetAddr