| from Cython.Compiler.Visitor import CythonTransform |
| from Cython.Compiler.StringEncoding import EncodedString |
| from Cython.Compiler import Options |
| from Cython.Compiler import PyrexTypes, ExprNodes |
| |
| class EmbedSignature(CythonTransform): |
| |
| def __init__(self, context): |
| super(EmbedSignature, self).__init__(context) |
| self.denv = None # XXX |
| self.class_name = None |
| self.class_node = None |
| |
| unop_precedence = 11 |
| binop_precedence = { |
| 'or': 1, |
| 'and': 2, |
| 'not': 3, |
| 'in': 4, 'not in': 4, 'is': 4, 'is not': 4, '<': 4, '<=': 4, '>': 4, '>=': 4, '!=': 4, '==': 4, |
| '|': 5, |
| '^': 6, |
| '&': 7, |
| '<<': 8, '>>': 8, |
| '+': 9, '-': 9, |
| '*': 10, '/': 10, '//': 10, '%': 10, |
| # unary: '+': 11, '-': 11, '~': 11 |
| '**': 12} |
| |
| def _fmt_expr_node(self, node, precedence=0): |
| if isinstance(node, ExprNodes.BinopNode) and not node.inplace: |
| new_prec = self.binop_precedence.get(node.operator, 0) |
| result = '%s %s %s' % (self._fmt_expr_node(node.operand1, new_prec), |
| node.operator, |
| self._fmt_expr_node(node.operand2, new_prec)) |
| if precedence > new_prec: |
| result = '(%s)' % result |
| elif isinstance(node, ExprNodes.UnopNode): |
| result = '%s%s' % (node.operator, |
| self._fmt_expr_node(node.operand, self.unop_precedence)) |
| if precedence > self.unop_precedence: |
| result = '(%s)' % result |
| elif isinstance(node, ExprNodes.AttributeNode): |
| result = '%s.%s' % (self._fmt_expr_node(node.obj), node.attribute) |
| else: |
| result = node.name |
| return result |
| |
| def _fmt_arg_defv(self, arg): |
| default_val = arg.default |
| if not default_val: |
| return None |
| try: |
| denv = self.denv # XXX |
| ctval = default_val.compile_time_value(self.denv) |
| repr_val = repr(ctval) |
| if isinstance(default_val, ExprNodes.UnicodeNode): |
| if repr_val[:1] != 'u': |
| return u'u%s' % repr_val |
| elif isinstance(default_val, ExprNodes.BytesNode): |
| if repr_val[:1] != 'b': |
| return u'b%s' % repr_val |
| elif isinstance(default_val, ExprNodes.StringNode): |
| if repr_val[:1] in 'ub': |
| return repr_val[1:] |
| return repr_val |
| except Exception: |
| try: |
| return self._fmt_expr_node(default_val) |
| except AttributeError, e: |
| return '<???>' |
| |
| def _fmt_arg(self, arg): |
| if arg.type is PyrexTypes.py_object_type or arg.is_self_arg: |
| doc = arg.name |
| else: |
| doc = arg.type.declaration_code(arg.name, for_display=1) |
| if arg.default: |
| arg_defv = self._fmt_arg_defv(arg) |
| if arg_defv: |
| doc = doc + ('=%s' % arg_defv) |
| return doc |
| |
| def _fmt_arglist(self, args, |
| npargs=0, pargs=None, |
| nkargs=0, kargs=None, |
| hide_self=False): |
| arglist = [] |
| for arg in args: |
| if not hide_self or not arg.entry.is_self_arg: |
| arg_doc = self._fmt_arg(arg) |
| arglist.append(arg_doc) |
| if pargs: |
| arglist.insert(npargs, '*%s' % pargs.name) |
| elif nkargs: |
| arglist.insert(npargs, '*') |
| if kargs: |
| arglist.append('**%s' % kargs.name) |
| return arglist |
| |
| def _fmt_ret_type(self, ret): |
| if ret is PyrexTypes.py_object_type: |
| return None |
| else: |
| return ret.declaration_code("", for_display=1) |
| |
| def _fmt_signature(self, cls_name, func_name, args, |
| npargs=0, pargs=None, |
| nkargs=0, kargs=None, |
| return_type=None, hide_self=False): |
| arglist = self._fmt_arglist(args, |
| npargs, pargs, |
| nkargs, kargs, |
| hide_self=hide_self) |
| arglist_doc = ', '.join(arglist) |
| func_doc = '%s(%s)' % (func_name, arglist_doc) |
| if cls_name: |
| func_doc = '%s.%s' % (cls_name, func_doc) |
| if return_type: |
| ret_doc = self._fmt_ret_type(return_type) |
| if ret_doc: |
| func_doc = '%s -> %s' % (func_doc, ret_doc) |
| return func_doc |
| |
| def _embed_signature(self, signature, node_doc): |
| if node_doc: |
| return "%s\n%s" % (signature, node_doc) |
| else: |
| return signature |
| |
| def __call__(self, node): |
| if not Options.docstrings: |
| return node |
| else: |
| return super(EmbedSignature, self).__call__(node) |
| |
| def visit_ClassDefNode(self, node): |
| oldname = self.class_name |
| oldclass = self.class_node |
| self.class_node = node |
| try: |
| # PyClassDefNode |
| self.class_name = node.name |
| except AttributeError: |
| # CClassDefNode |
| self.class_name = node.class_name |
| self.visitchildren(node) |
| self.class_name = oldname |
| self.class_node = oldclass |
| return node |
| |
| def visit_DefNode(self, node): |
| if not self.current_directives['embedsignature']: |
| return node |
| |
| is_constructor = False |
| hide_self = False |
| if node.entry.is_special: |
| is_constructor = self.class_node and node.name == '__init__' |
| if not is_constructor: |
| return node |
| class_name, func_name = None, self.class_name |
| hide_self = True |
| else: |
| class_name, func_name = self.class_name, node.name |
| |
| nkargs = getattr(node, 'num_kwonly_args', 0) |
| npargs = len(node.args) - nkargs |
| signature = self._fmt_signature( |
| class_name, func_name, node.args, |
| npargs, node.star_arg, |
| nkargs, node.starstar_arg, |
| return_type=None, hide_self=hide_self) |
| if signature: |
| if is_constructor: |
| doc_holder = self.class_node.entry.type.scope |
| else: |
| doc_holder = node.entry |
| |
| if doc_holder.doc is not None: |
| old_doc = doc_holder.doc |
| elif not is_constructor and getattr(node, 'py_func', None) is not None: |
| old_doc = node.py_func.entry.doc |
| else: |
| old_doc = None |
| new_doc = self._embed_signature(signature, old_doc) |
| doc_holder.doc = EncodedString(new_doc) |
| if not is_constructor and getattr(node, 'py_func', None) is not None: |
| node.py_func.entry.doc = EncodedString(new_doc) |
| return node |
| |
| def visit_CFuncDefNode(self, node): |
| if not self.current_directives['embedsignature']: |
| return node |
| if not node.overridable: # not cpdef FOO(...): |
| return node |
| |
| signature = self._fmt_signature( |
| self.class_name, node.declarator.base.name, |
| node.declarator.args, |
| return_type=node.return_type) |
| if signature: |
| if node.entry.doc is not None: |
| old_doc = node.entry.doc |
| elif getattr(node, 'py_func', None) is not None: |
| old_doc = node.py_func.entry.doc |
| else: |
| old_doc = None |
| new_doc = self._embed_signature(signature, old_doc) |
| node.entry.doc = EncodedString(new_doc) |
| if hasattr(node, 'py_func') and node.py_func is not None: |
| node.py_func.entry.doc = EncodedString(new_doc) |
| return node |
| |
| def visit_PropertyNode(self, node): |
| if not self.current_directives['embedsignature']: |
| return node |
| |
| entry = node.entry |
| if entry.visibility == 'public': |
| # property synthesised from a cdef public attribute |
| type_name = entry.type.declaration_code("", for_display=1) |
| if not entry.type.is_pyobject: |
| type_name = "'%s'" % type_name |
| elif entry.type.is_extension_type: |
| type_name = entry.type.module_name + '.' + type_name |
| signature = '%s: %s' % (entry.name, type_name) |
| new_doc = self._embed_signature(signature, entry.doc) |
| entry.doc = EncodedString(new_doc) |
| return node |
