Cython bang operator overloading.

Cython/Compiler/ExprNodes.py

@@ -7021,6 +7021,20 @@ class CUnopNode(UnopNode):
     def is_py_operation(self):
         return False
 
+class BangNode(CUnopNode):
+    #  unary ! operator
+
+    operator = '!'
+
+    def analyse_c_operation(self, env):
+        if self.operand.type.is_ptr or self.operand.type.is_numeric:
+            self.type = PyrexTypes.c_bint_type
+        else:
+            self.type_error()
+
+    def calculate_result_code(self):
+        return "(!%s)" % self.operand.result()
+
 class DereferenceNode(CUnopNode):
     #  unary * operator
 

Cython/Compiler/Lexicon.py

@@ -73,7 +73,7 @@ def make_lexicon():
     deco = Str("@")
     bra = Any("([{")
     ket = Any(")]}")
-    punct = Any(":,;+-*/|&<>=.%`~^?")
+    punct = Any(":,;+-*/|&<>=.%`~^?!")
     diphthong = Str("==", "<>", "!=", "<=", ">=", "<<", ">>", "**", "//",
                     "+=", "-=", "*=", "/=", "%=", "|=", "^=", "&=",
                     "<<=", ">>=", "**=", "//=", "->")

Cython/Compiler/ParseTreeTransforms.py

@@ -614,6 +614,7 @@ class InterpretCompilerDirectives(CythonTransform, SkipDeclarations):
         'typeof': ExprNodes.TypeofNode,
 
         'operator.address': ExprNodes.AmpersandNode,
+        'operator.bang': ExprNodes.BangNode,
         'operator.dereference': ExprNodes.DereferenceNode,
         'operator.preincrement' : ExprNodes.inc_dec_constructor(True, '++'),
         'operator.predecrement' : ExprNodes.inc_dec_constructor(True, '--'),

Cython/Compiler/Parsing.py

@@ -2297,7 +2297,7 @@ supported_overloaded_operators = set([
     '+', '-', '*', '/', '%',
     '++', '--', '~', '|', '&', '^', '<<', '>>', ',',
     '==', '!=', '>=', '>', '<=', '<',
-    '[]', '()',
+    '[]', '()', '!',
 ])
 
 def p_c_simple_declarator(s, ctx, empty, is_type, cmethod_flag,
@@ -2345,7 +2345,7 @@ def p_c_simple_declarator(s, ctx, empty, is_type, cmethod_flag,
             cname = ctx.namespace + "::" + name
         if name == 'operator' and ctx.visibility == 'extern' and nonempty:
             op = s.sy
-            if [1 for c in op if c in '+-*/<=>!%&|([^~,']:
+            if [1 for c in op if c in '+-*/<=>!%&|([^~,!']:
                 s.next()
                 # Handle diphthong operators.
                 if op == '(':

docs/src/userguide/wrapping_CPlusPlus.rst

@@ -332,9 +332,11 @@ syntax as C++. Cython provides functions replacing these operators in
 a special module ``cython.operator``. The functions provided are:
 
 * ``cython.operator.dereference`` for dereferencing. ``dereference(foo)``
-  will produce the C++ code ``*foo``
+  will produce the C++ code ``*(foo)``
+* ``cython.operator.bang`` for not. ``bang(foo)``
+  will produce the C++ code ``!(foo)``
 * ``cython.operator.preincrement`` for pre-incrementation. ``preincrement(foo)``
-  will produce the C++ code ``++foo``
+  will produce the C++ code ``++(foo)``
 * ...
 
 These functions need to be cimported. Of course, one can use a

tests/run/cpp_operators.pyx

@@ -13,6 +13,7 @@ cdef extern from "cpp_operators_helper.h":
         char* operator-()
         char* operator*()
         char* operator~()
+        char* operator!()
 
         char* operator++()
         char* operator--()
@@ -50,12 +51,14 @@ def test_unops():
     unary -
     unary ~
     unary *
+    unary !
     """
     cdef TestOps* t = new TestOps()
     out(+t[0])
     out(-t[0])
     out(~t[0])
     out(deref(t[0]))
+    out(cython.operator.bang(t[0]))
     del t
 
 def test_incdec():