113 lines
3.5 KiB
Python
113 lines
3.5 KiB
Python
"""Variables, arguments and argument transfer modes etc."""
|
|
|
|
|
|
# Values to represent argument transfer modes
|
|
InMode = 1 # input-only argument
|
|
OutMode = 2 # output-only argument
|
|
InOutMode = 3 # input-output argument
|
|
ModeMask = 3 # bits to keep for mode
|
|
|
|
|
|
# Special cases for mode/flags argument
|
|
# XXX This is still a mess!
|
|
SelfMode = 4+InMode # this is 'self' -- don't declare it
|
|
ReturnMode = 8+OutMode # this is the function return value
|
|
ErrorMode = 16+OutMode # this is an error status -- turn it into an exception
|
|
RefMode = 32
|
|
ConstMode = 64
|
|
|
|
class Variable:
|
|
|
|
"""A Variable holds a type, a name, a transfer mode and flags.
|
|
|
|
Most of its methods call the correponding type method with the
|
|
variable name.
|
|
"""
|
|
|
|
def __init__(self, type, name = None, flags = InMode):
|
|
"""Call with a type, a name and flags.
|
|
|
|
If name is None, it muse be set later.
|
|
flags defaults to InMode.
|
|
"""
|
|
self.type = type
|
|
self.name = name
|
|
self.flags = flags
|
|
self.mode = flags & ModeMask
|
|
|
|
def declare(self):
|
|
"""Declare the variable if necessary.
|
|
|
|
If it is "self", it is not declared.
|
|
"""
|
|
if self.flags == ReturnMode+RefMode:
|
|
self.type.declare(self.name, reference=True)
|
|
elif self.flags != SelfMode:
|
|
self.type.declare(self.name)
|
|
|
|
def getArgDeclarations(self, fullmodes=False):
|
|
refmode = (self.flags & RefMode)
|
|
constmode = False
|
|
outmode = False
|
|
if fullmodes:
|
|
constmode = (self.flags & ConstMode)
|
|
outmode = (self.flags & OutMode)
|
|
return self.type.getArgDeclarations(self.name,
|
|
reference=refmode, constmode=constmode, outmode=outmode)
|
|
|
|
def getAuxDeclarations(self):
|
|
return self.type.getAuxDeclarations(self.name)
|
|
|
|
def getargsFormat(self):
|
|
"""Call the type's getargsFormatmethod."""
|
|
return self.type.getargsFormat()
|
|
|
|
def getargsArgs(self):
|
|
"""Call the type's getargsArgsmethod."""
|
|
return self.type.getargsArgs(self.name)
|
|
|
|
def getargsCheck(self):
|
|
return self.type.getargsCheck(self.name)
|
|
|
|
def getargsPreCheck(self):
|
|
return self.type.getargsPreCheck(self.name)
|
|
|
|
def passArgument(self):
|
|
"""Return the string required to pass the variable as argument.
|
|
|
|
For "in" arguments, return the variable name.
|
|
For "out" and "in out" arguments,
|
|
return its name prefixed with "&".
|
|
"""
|
|
if self.mode == InMode:
|
|
return self.type.passInput(self.name)
|
|
if self.mode & RefMode:
|
|
return self.type.passReference(self.name)
|
|
if self.mode in (OutMode, InOutMode):
|
|
return self.type.passOutput(self.name)
|
|
# XXX Shouldn't get here
|
|
return "/*mode?*/" + self.type.passInput(self.name)
|
|
|
|
def errorCheck(self):
|
|
"""Check for an error if necessary.
|
|
|
|
This only generates code if the variable's mode is ErrorMode.
|
|
"""
|
|
if self.flags == ErrorMode:
|
|
self.type.errorCheck(self.name)
|
|
|
|
def mkvalueFormat (self):
|
|
"""Call the type's mkvalueFormat method."""
|
|
return self.type.mkvalueFormat()
|
|
|
|
def mkvalueArgs(self):
|
|
"""Call the type's mkvalueArgs method."""
|
|
return self.type.mkvalueArgs(self.name)
|
|
|
|
def mkvaluePreCheck(self):
|
|
return self.type.mkvaluePreCheck(self.name)
|
|
|
|
def cleanup(self):
|
|
"""Call the type's cleanup method."""
|
|
return self.type.cleanup(self.name)
|