| from bgenOutput import * | |
| from bgenType import * | |
| from bgenVariable import * | |
| Error = "bgenGenerator.Error" | |
| DEBUG=0 | |
| # Strings to specify argument transfer modes in generator calls | |
| IN = "in" | |
| OUT = "out" | |
| INOUT = IN_OUT = "in-out" | |
| class BaseFunctionGenerator: | |
| def __init__(self, name, condition=None, callname=None, modifiers=None): | |
| if DEBUG: print "<--", name | |
| self.name = name | |
| if callname: | |
| self.callname = callname | |
| else: | |
| self.callname = name | |
| self.prefix = name | |
| self.objecttype = "PyObject" # Type of _self argument to function | |
| self.condition = condition | |
| self.modifiers = modifiers | |
| def setprefix(self, prefix): | |
| self.prefix = prefix | |
| def checkgenerate(self): | |
| return True | |
| def generate(self): | |
| if not self.checkgenerate(): | |
| return | |
| if DEBUG: print "-->", self.name | |
| if self.condition: | |
| Output() | |
| Output(self.condition) | |
| self.functionheader() | |
| self.functionbody() | |
| self.functiontrailer() | |
| if self.condition: | |
| Output("#endif") | |
| def functionheader(self): | |
| Output() | |
| Output("static PyObject *%s_%s(%s *_self, PyObject *_args)", | |
| self.prefix, self.name, self.objecttype) | |
| OutLbrace() | |
| Output("PyObject *_res = NULL;") | |
| def functionbody(self): | |
| Output("/* XXX To be provided */") | |
| def functiontrailer(self): | |
| OutRbrace() | |
| def reference(self, name = None): | |
| if not self.checkgenerate(): | |
| return | |
| if name is None: | |
| name = self.name | |
| docstring = self.docstring() | |
| if self.condition: | |
| Output() | |
| Output(self.condition) | |
| Output("{\"%s\", (PyCFunction)%s_%s, 1,", name, self.prefix, self.name) | |
| Output(" PyDoc_STR(%s)},", stringify(docstring)) | |
| if self.condition: | |
| Output("#endif") | |
| def docstring(self): | |
| return None | |
| def __cmp__(self, other): | |
| if not hasattr(other, 'name'): | |
| return cmp(id(self), id(other)) | |
| return cmp(self.name, other.name) | |
| _stringify_map = {'\n': '\\n', '\t': '\\t', '\r': '\\r', '\b': '\\b', | |
| '\e': '\\e', '\a': '\\a', '\f': '\\f', '"': '\\"'} | |
| def stringify(str): | |
| if str is None: return "NULL" | |
| res = '"' | |
| map = _stringify_map | |
| for c in str: | |
| if map.has_key(c): res = res + map[c] | |
| elif ' ' <= c <= '~': res = res + c | |
| else: res = res + '\\%03o' % ord(c) | |
| res = res + '"' | |
| return res | |
| class ManualGenerator(BaseFunctionGenerator): | |
| def __init__(self, name, body, condition=None): | |
| BaseFunctionGenerator.__init__(self, name, condition=condition) | |
| self.body = body | |
| def functionbody(self): | |
| Output("%s", self.body) | |
| def setselftype(self, selftype, itselftype): | |
| self.objecttype = selftype | |
| self.itselftype = itselftype | |
| class FunctionGenerator(BaseFunctionGenerator): | |
| def __init__(self, returntype, name, *argumentList, **conditionlist): | |
| BaseFunctionGenerator.__init__(self, name, **conditionlist) | |
| self.returntype = returntype | |
| self.argumentList = [] | |
| self.setreturnvar() | |
| self.parseArgumentList(argumentList) | |
| self.prefix = "XXX" # Will be changed by setprefix() call | |
| self.itselftype = None # Type of _self->ob_itself, if defined | |
| def setreturnvar(self): | |
| if self.returntype: | |
| self.rv = self.makereturnvar() | |
| self.argumentList.append(self.rv) | |
| else: | |
| self.rv = None | |
| def makereturnvar(self): | |
| return Variable(self.returntype, "_rv", OutMode) | |
| def setselftype(self, selftype, itselftype): | |
| self.objecttype = selftype | |
| self.itselftype = itselftype | |
| def parseArgumentList(self, argumentList): | |
| iarg = 0 | |
| for type, name, mode in argumentList: | |
| iarg = iarg + 1 | |
| if name is None: name = "_arg%d" % iarg | |
| arg = Variable(type, name, mode) | |
| self.argumentList.append(arg) | |
| def docstring(self): | |
| input = [] | |
| output = [] | |
| for arg in self.argumentList: | |
| if arg.flags == ErrorMode or arg.flags == SelfMode: | |
| continue | |
| if arg.type is None: | |
| str = 'void' | |
| else: | |
| if hasattr(arg.type, 'typeName'): | |
| typeName = arg.type.typeName | |
| if typeName is None: # Suppressed type | |
| continue | |
| else: | |
| typeName = "?" | |
| print "Nameless type", arg.type | |
| str = typeName + ' ' + arg.name | |
| if arg.mode in (InMode, InOutMode): | |
| input.append(str) | |
| if arg.mode in (InOutMode, OutMode): | |
| output.append(str) | |
| if not input: | |
| instr = "()" | |
| else: | |
| instr = "(%s)" % ", ".join(input) | |
| if not output or output == ["void"]: | |
| outstr = "None" | |
| else: | |
| outstr = "(%s)" % ", ".join(output) | |
| return instr + " -> " + outstr | |
| def functionbody(self): | |
| self.declarations() | |
| self.precheck() | |
| self.getargs() | |
| self.callit() | |
| self.checkit() | |
| self.returnvalue() | |
| def declarations(self): | |
| for arg in self.argumentList: | |
| arg.declare() | |
| def getargs(self): | |
| sep = ",\n" + ' '*len("if (!PyArg_ParseTuple(") | |
| fmt, lst = self.getargsFormatArgs(sep) | |
| Output("if (!PyArg_ParseTuple(_args, \"%s\"%s))", fmt, lst) | |
| IndentLevel() | |
| Output("return NULL;") | |
| DedentLevel() | |
| for arg in self.argumentList: | |
| if arg.flags == SelfMode: | |
| continue | |
| if arg.mode in (InMode, InOutMode): | |
| arg.getargsCheck() | |
| def getargsFormatArgs(self, sep): | |
| fmt = "" | |
| lst = "" | |
| for arg in self.argumentList: | |
| if arg.flags == SelfMode: | |
| continue | |
| if arg.mode in (InMode, InOutMode): | |
| arg.getargsPreCheck() | |
| fmt = fmt + arg.getargsFormat() | |
| args = arg.getargsArgs() | |
| if args: | |
| lst = lst + sep + args | |
| return fmt, lst | |
| def precheck(self): | |
| pass | |
| def beginallowthreads(self): | |
| pass | |
| def endallowthreads(self): | |
| pass | |
| def callit(self): | |
| args = "" | |
| s = "%s%s(" % (self.getrvforcallit(), self.callname) | |
| sep = ",\n" + ' '*len(s) | |
| for arg in self.argumentList: | |
| if arg is self.rv: | |
| continue | |
| s = arg.passArgument() | |
| if args: s = sep + s | |
| args = args + s | |
| self.beginallowthreads() | |
| Output("%s%s(%s);", | |
| self.getrvforcallit(), self.callname, args) | |
| self.endallowthreads() | |
| def getrvforcallit(self): | |
| if self.rv: | |
| return "%s = " % self.rv.name | |
| else: | |
| return "" | |
| def checkit(self): | |
| for arg in self.argumentList: | |
| arg.errorCheck() | |
| def returnvalue(self): | |
| sep = ",\n" + ' '*len("return Py_BuildValue(") | |
| fmt, lst = self.mkvalueFormatArgs(sep) | |
| if fmt == "": | |
| Output("Py_INCREF(Py_None);") | |
| Output("_res = Py_None;"); | |
| else: | |
| Output("_res = Py_BuildValue(\"%s\"%s);", fmt, lst) | |
| tmp = self.argumentList[:] | |
| tmp.reverse() | |
| for arg in tmp: | |
| if not arg: continue | |
| arg.cleanup() | |
| Output("return _res;") | |
| def mkvalueFormatArgs(self, sep): | |
| fmt = "" | |
| lst = "" | |
| for arg in self.argumentList: | |
| if not arg: continue | |
| if arg.flags == ErrorMode: continue | |
| if arg.mode in (OutMode, InOutMode): | |
| arg.mkvaluePreCheck() | |
| fmt = fmt + arg.mkvalueFormat() | |
| lst = lst + sep + arg.mkvalueArgs() | |
| return fmt, lst | |
| class MethodGenerator(FunctionGenerator): | |
| def parseArgumentList(self, args): | |
| a0, args = args[0], args[1:] | |
| t0, n0, m0 = a0 | |
| if m0 != InMode: | |
| raise ValueError, "method's 'self' must be 'InMode'" | |
| self.itself = Variable(t0, "_self->ob_itself", SelfMode) | |
| self.argumentList.append(self.itself) | |
| FunctionGenerator.parseArgumentList(self, args) | |
| def _test(): | |
| void = None | |
| eggs = FunctionGenerator(void, "eggs", | |
| (stringptr, 'cmd', InMode), | |
| (int, 'x', InMode), | |
| (double, 'y', InOutMode), | |
| (int, 'status', ErrorMode), | |
| ) | |
| eggs.setprefix("spam") | |
| print "/* START */" | |
| eggs.generate() | |
| if __name__ == "__main__": | |
| _test() |