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