| """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) |