scoped_name.py

# SPDX-License-Identifier: BSD-2-Clause

# Copyright (c) 2024 Phil Thompson <phil@riverbankcomputing.com>



# Specify how scopes should be stripped. Any other value is the number of
# scopes to strip.
STRIP_NONE=0# Don't strip any scopes.
STRIP_GLOBAL=-1# Strip the global scope.


classScopedName:
""" Encapsulate a scoped name. """

def__init__(self, name):
""" Initialise the scoped name. """

ifisinstance(name, list):
# This use is internal to this class.
self._name=name
elifisinstance(name, ScopedName):
# Make a copy of another ScopedName object.
self._name=list(name._name)
else:
# Create a simple name.
self._name= [name]

def__eq__(self, other):
""" Compare with another scoped name for equality. """

ifisinstance(other, ScopedName):
returnself._name==other._name

returnNotImplemented

def__delitem__(self, index):
""" Remove the requested name. """

delself._name[self._normalised_index(index)]

def__getitem__(self, index):
""" Get the requested name. """

returnself._name[self._normalised_index(index)]

def__len__(self):
""" Return the length of the name, ie. the number of individual names.
 """

nr_names=len(self._name)

ifself.is_absolute:
nr_names-=1

returnnr_names

def__lt__(self, other):
""" Compare with another scoped name to allow lists to be sorted. """

ifisinstance(other, ScopedName):
returnself._name<other._name

returnNotImplemented

def__setitem__(self, index, name):
""" Set the requested name. """

self._name[self._normalised_index(index)] =name

def__str__(self):
""" Return the C++ string representation. """

# The special treatment is a hack to simplify how the result is used.
# We ignore any leading '::' and truncate the conversion if we think we
# are converting an encoded template name (ie. we find a word that
# starts with a digit).
s_l= []
forsinself:
ifs[0].isdigit():
break

s_l.append(s)

return'::'.join(s_l)

@property
defabsolute(self):
""" The absolute version of the name. """

ifself.is_absolute:
returnself

copy=type(self)(self)
copy.make_absolute()

returncopy

defappend(self, name):
""" Append a simple name. """

self._name.append(name)

@property
defas_cpp(self):
""" The C++ representation of the name. """

return'::'.join(self._name)

@property
defas_py(self):
""" The Python representation of the name. """

start=1ifself.is_absoluteelse0

return'.'.join(self._name[start:])

@property
defas_word(self):
""" The word representation of the name. """

start=1ifself.is_absoluteelse0

return'_'.join(self._name[start:])

@property
defbase_name(self):
""" The base name of the scoped name. """

returnself._name[-1]

defcpp_stripped(self, strip):
""" Return the C++ representation of the name with leading scopes
 stripped.
 """

ifstrip==STRIP_NONE:
start=0
else:
start=1ifself.is_absoluteelse0

ifstrip!=STRIP_GLOBAL:
start+=strip

# Never strip the base name.
ifstart>=len(self._name):
returnself._name[-1]

return'::'.join(self._name[start:])

@property
defis_absolute(self):
""" True if the scoped name is absolute. """

returnself._name[0] ==''

@property
defis_simple(self):
""" Return True if the name is simple, ie. relative and unscoped. """

returnlen(self) ==1

defmake_absolute(self):
""" Make sure the scoped name is absolute. """

ifself._name[0] !='':
self._name.insert(0, '')

defmatches(self, scoped_name, scope=None):
""" Return True if a scoped name matches this taking account of an
 optional scope if the scoped name is relative.
 """

assertself.is_absolute

# Check for the simple case.
ifscoped_name.is_absolute:
returnself==scoped_name

# Try each scope, inner to outer.
whilescopeisnotNone:
fq_name=ScopedName(scope.iface_file.fq_cpp_name)
fq_name._name.extend(scoped_name._name)

ifself==fq_name:
returnTrue

scope=scope.scope

# Treat the name as if it were absolute.
returnself._name[1:] ==scoped_name._name

@classmethod
defparse(cls, raw):
""" Return a ScopedName object by parsing a raw string. """

returncls(raw.split('::'))

defprepend(self, scoped_name):
""" Prepend a scoped name. """

new_name=list(scoped_name._name)
new_name.extend(self._name)
self._name=new_name

@property
defscope(self):
""" The scoped name that is the enclosing scope of this one. It will
 be None if there isn't one.
 """

iflen(self) ==1:
returnNone

returntype(self)(self._name[:-1])

def_normalised_index(self, index):
""" Return a normalised index. """

ifnotisinstance(index, int):
raiseTypeError("'{}' is an invalid index".format(type(index)))

ifindex>=0andself.is_absolute:
index+=1

returnindex