paul@324 | 1 | #!/usr/bin/env python |
paul@324 | 2 | |
paul@324 | 3 | """ |
paul@324 | 4 | Operator support. |
paul@324 | 5 | |
paul@651 | 6 | Copyright (C) 2010, 2013 Paul Boddie <paul@boddie.org.uk> |
paul@324 | 7 | |
paul@324 | 8 | This program is free software; you can redistribute it and/or modify it under |
paul@324 | 9 | the terms of the GNU General Public License as published by the Free Software |
paul@324 | 10 | Foundation; either version 3 of the License, or (at your option) any later |
paul@324 | 11 | version. |
paul@324 | 12 | |
paul@324 | 13 | This program is distributed in the hope that it will be useful, but WITHOUT |
paul@324 | 14 | ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS |
paul@324 | 15 | FOR A PARTICULAR PURPOSE. See the GNU General Public License for more |
paul@324 | 16 | details. |
paul@324 | 17 | |
paul@324 | 18 | You should have received a copy of the GNU General Public License along with |
paul@324 | 19 | this program. If not, see <http://www.gnu.org/licenses/>. |
paul@324 | 20 | """ |
paul@324 | 21 | |
paul@325 | 22 | def binary_op(a, b, left_accessor, right_accessor): |
paul@324 | 23 | |
paul@324 | 24 | """ |
paul@324 | 25 | A single parameterised function providing the binary operator mechanism for |
paul@325 | 26 | arguments 'a' and 'b' using accessors given as 'left_accessor' and |
paul@325 | 27 | 'right_accessor' which provide the methods for the operands. |
paul@324 | 28 | """ |
paul@324 | 29 | |
paul@324 | 30 | # First, try and get a method for the left argument, and then call it with |
paul@324 | 31 | # the right argument. |
paul@324 | 32 | |
paul@324 | 33 | try: |
paul@325 | 34 | fn = left_accessor(a) |
paul@324 | 35 | except AttributeError: |
paul@324 | 36 | pass |
paul@324 | 37 | else: |
paul@324 | 38 | result = fn(b) |
paul@324 | 39 | if result is not NotImplemented: |
paul@324 | 40 | return result |
paul@324 | 41 | |
paul@324 | 42 | # Otherwise, try and get a method for the right argument, and then call it |
paul@324 | 43 | # with the left argument. |
paul@324 | 44 | |
paul@324 | 45 | try: |
paul@325 | 46 | fn = right_accessor(b) |
paul@324 | 47 | except AttributeError: |
paul@324 | 48 | pass |
paul@324 | 49 | else: |
paul@324 | 50 | result = fn(a) |
paul@324 | 51 | if result is not NotImplemented: |
paul@324 | 52 | return result |
paul@324 | 53 | |
paul@324 | 54 | # Where no methods were available, or if neither method could support the |
paul@324 | 55 | # operation, raise an exception. |
paul@324 | 56 | |
paul@324 | 57 | raise TypeError |
paul@324 | 58 | |
paul@354 | 59 | def unary_op(a, accessor): |
paul@354 | 60 | |
paul@354 | 61 | """ |
paul@354 | 62 | A single parameterised function providing the unary operator mechanism for |
paul@354 | 63 | the argument 'a' using the given 'accessor' to provide the method for the |
paul@354 | 64 | operand. |
paul@354 | 65 | """ |
paul@354 | 66 | |
paul@354 | 67 | # First, try and get a method for the argument, and then call it. |
paul@354 | 68 | |
paul@354 | 69 | try: |
paul@354 | 70 | fn = accessor(a) |
paul@354 | 71 | except AttributeError: |
paul@354 | 72 | pass |
paul@354 | 73 | else: |
paul@354 | 74 | result = fn() |
paul@354 | 75 | if result is not NotImplemented: |
paul@354 | 76 | return result |
paul@354 | 77 | |
paul@354 | 78 | # Where no method was available, or if the method could not support the |
paul@354 | 79 | # operation, raise an exception. |
paul@354 | 80 | |
paul@354 | 81 | raise TypeError |
paul@354 | 82 | |
paul@354 | 83 | def augassign(a, b, augmented_accessor, left_accessor, right_accessor): |
paul@354 | 84 | |
paul@354 | 85 | """ |
paul@354 | 86 | A single parameterised function providing the augmented assignment mechanism |
paul@354 | 87 | for arguments 'a' and 'b' either using 'augmented_accessor' (directly |
paul@354 | 88 | affecting 'a') or using 'left_accessor' and 'right_accessor' (conventional |
paul@354 | 89 | operator method accessors). |
paul@354 | 90 | |
paul@354 | 91 | The result of the assignment is returned. |
paul@354 | 92 | """ |
paul@354 | 93 | |
paul@354 | 94 | # First, try and get a method that directly affects the assignment target. |
paul@354 | 95 | |
paul@354 | 96 | try: |
paul@354 | 97 | fn = augmented_accessor(a) |
paul@354 | 98 | except AttributeError: |
paul@354 | 99 | pass |
paul@354 | 100 | else: |
paul@354 | 101 | result = fn(b) |
paul@354 | 102 | if result is not NotImplemented: |
paul@354 | 103 | return result |
paul@354 | 104 | |
paul@354 | 105 | # Otherwise, attempt a conventional binary operation. |
paul@354 | 106 | |
paul@354 | 107 | return binary_op(a, b, left_accessor, right_accessor) |
paul@354 | 108 | |
paul@325 | 109 | # These functions defer method lookup by wrapping the attribute access in |
paul@325 | 110 | # lambda functions. Thus, the appropriate methods are defined locally, but no |
paul@325 | 111 | # attempt to obtain them is made until the generic function is called. |
paul@325 | 112 | |
paul@354 | 113 | # NOTE: The compiler should make it possible for the following functions to call |
paul@354 | 114 | # NOTE: the generic operator implementations with no additional call overhead. |
paul@354 | 115 | |
paul@354 | 116 | # Binary operator functions. |
paul@325 | 117 | |
paul@324 | 118 | def add(a, b): |
paul@325 | 119 | return binary_op(a, b, lambda a: a.__add__, lambda b: b.__radd__) |
paul@324 | 120 | |
paul@324 | 121 | def and_(a, b): |
paul@325 | 122 | return binary_op(a, b, lambda a: a.__and__, lambda b: b.__rand__) |
paul@324 | 123 | |
paul@651 | 124 | def contains(a, b): |
paul@651 | 125 | return b in a |
paul@651 | 126 | |
paul@324 | 127 | def div(a, b): |
paul@325 | 128 | return binary_op(a, b, lambda a: a.__div__, lambda b: b.__rdiv__) |
paul@324 | 129 | |
paul@324 | 130 | def floordiv(a, b): |
paul@325 | 131 | return binary_op(a, b, lambda a: a.__floordiv__, lambda b: b.__rfloordiv__) |
paul@324 | 132 | |
paul@668 | 133 | def in_(a, b): |
paul@668 | 134 | return a.__contains__(b) |
paul@668 | 135 | |
paul@324 | 136 | def lshift(a, b): |
paul@325 | 137 | return binary_op(a, b, lambda a: a.__lshift__, lambda b: b.__rlshift__) |
paul@324 | 138 | |
paul@324 | 139 | def mod(a, b): |
paul@325 | 140 | return binary_op(a, b, lambda a: a.__mod__, lambda b: b.__rmod__) |
paul@324 | 141 | |
paul@324 | 142 | def mul(a, b): |
paul@325 | 143 | return binary_op(a, b, lambda a: a.__mul__, lambda b: b.__rmul__) |
paul@324 | 144 | |
paul@328 | 145 | def or_(a, b): |
paul@325 | 146 | return binary_op(a, b, lambda a: a.__or__, lambda b: b.__ror__) |
paul@324 | 147 | |
paul@324 | 148 | def pow(a, b): |
paul@325 | 149 | return binary_op(a, b, lambda a: a.__pow__, lambda b: b.__rpow__) |
paul@324 | 150 | |
paul@324 | 151 | def rshift(a, b): |
paul@325 | 152 | return binary_op(a, b, lambda a: a.__rshift__, lambda b: b.__rrshift__) |
paul@324 | 153 | |
paul@324 | 154 | def sub(a, b): |
paul@325 | 155 | return binary_op(a, b, lambda a: a.__sub__, lambda b: b.__rsub__) |
paul@324 | 156 | |
paul@324 | 157 | def xor(a, b): |
paul@325 | 158 | return binary_op(a, b, lambda a: a.__xor__, lambda b: b.__rxor__) |
paul@324 | 159 | |
paul@354 | 160 | # Unary operator functions. |
paul@354 | 161 | |
paul@354 | 162 | def invert(a): |
paul@354 | 163 | return unary_op(a, lambda a: a.__invert__) |
paul@354 | 164 | |
paul@354 | 165 | def neg(a): |
paul@354 | 166 | return unary_op(a, lambda a: a.__neg__) |
paul@354 | 167 | |
paul@651 | 168 | def not_(a): |
paul@651 | 169 | return not a |
paul@651 | 170 | |
paul@354 | 171 | def pos(a): |
paul@354 | 172 | return unary_op(a, lambda a: a.__pos__) |
paul@354 | 173 | |
paul@354 | 174 | # Augmented assignment functions. |
paul@354 | 175 | |
paul@354 | 176 | def iadd(a, b): |
paul@354 | 177 | return augassign(a, b, lambda a: a.__iadd__, lambda a: a.__add__, lambda b: b.__radd__) |
paul@354 | 178 | |
paul@354 | 179 | def iand_(a, b): |
paul@354 | 180 | return augassign(a, b, lambda a: a.__iand__, lambda a: a.__and__, lambda b: b.__rand__) |
paul@354 | 181 | |
paul@354 | 182 | def idiv(a, b): |
paul@354 | 183 | return augassign(a, b, lambda a: a.__idiv__, lambda a: a.__div__, lambda b: b.__rdiv__) |
paul@354 | 184 | |
paul@354 | 185 | def ifloordiv(a, b): |
paul@354 | 186 | return augassign(a, b, lambda a: a.__ifloordiv__, lambda a: a.__floordiv__, lambda b: b.__rfloordiv__) |
paul@354 | 187 | |
paul@354 | 188 | def ilshift(a, b): |
paul@354 | 189 | return augassign(a, b, lambda a: a.__ilshift__, lambda a: a.__lshift__, lambda b: b.__rlshift__) |
paul@354 | 190 | |
paul@354 | 191 | def imod(a, b): |
paul@354 | 192 | return augassign(a, b, lambda a: a.__imod__, lambda a: a.__mod__, lambda b: b.__rmod__) |
paul@354 | 193 | |
paul@354 | 194 | def imul(a, b): |
paul@354 | 195 | return augassign(a, b, lambda a: a.__imul__, lambda a: a.__mul__, lambda b: b.__rmul__) |
paul@354 | 196 | |
paul@354 | 197 | def ior_(a, b): |
paul@354 | 198 | return augassign(a, b, lambda a: a.__ior__, lambda a: a.__or__, lambda b: b.__ror__) |
paul@354 | 199 | |
paul@354 | 200 | def ipow(a, b): |
paul@354 | 201 | return augassign(a, b, lambda a: a.__ipow__, lambda a: a.__pow__, lambda b: b.__rpow__) |
paul@354 | 202 | |
paul@354 | 203 | def irshift(a, b): |
paul@354 | 204 | return augassign(a, b, lambda a: a.__irshift__, lambda a: a.__rshift__, lambda b: b.__rrshift__) |
paul@354 | 205 | |
paul@354 | 206 | def isub(a, b): |
paul@354 | 207 | return augassign(a, b, lambda a: a.__isub__, lambda a: a.__sub__, lambda b: b.__rsub__) |
paul@354 | 208 | |
paul@354 | 209 | def ixor(a, b): |
paul@354 | 210 | return augassign(a, b, lambda a: a.__ixor__, lambda a: a.__xor__, lambda b: b.__rxor__) |
paul@354 | 211 | |
paul@354 | 212 | # Comparison functions. |
paul@354 | 213 | |
paul@354 | 214 | def eq(a, b): |
paul@354 | 215 | return binary_op(a, b, lambda a: a.__eq__, lambda b: b.__eq__) |
paul@354 | 216 | |
paul@354 | 217 | def ge(a, b): |
paul@354 | 218 | return binary_op(a, b, lambda a: a.__ge__, lambda b: b.__le__) |
paul@354 | 219 | |
paul@354 | 220 | def gt(a, b): |
paul@354 | 221 | return binary_op(a, b, lambda a: a.__gt__, lambda b: b.__lt__) |
paul@354 | 222 | |
paul@354 | 223 | def le(a, b): |
paul@354 | 224 | return binary_op(a, b, lambda a: a.__le__, lambda b: b.__ge__) |
paul@354 | 225 | |
paul@354 | 226 | def lt(a, b): |
paul@354 | 227 | return binary_op(a, b, lambda a: a.__lt__, lambda b: b.__gt__) |
paul@354 | 228 | |
paul@354 | 229 | def ne(a, b): |
paul@354 | 230 | return binary_op(a, b, lambda a: a.__ne__, lambda b: b.__ne__) |
paul@354 | 231 | |
paul@374 | 232 | # Access and slicing functions. |
paul@374 | 233 | |
paul@374 | 234 | def getitem(a, b): |
paul@374 | 235 | return a.__getitem__(b) |
paul@374 | 236 | |
paul@374 | 237 | def setitem(a, b, c): |
paul@374 | 238 | a.__setitem__(b, c) |
paul@374 | 239 | |
paul@374 | 240 | # NOTE: Should be able to optimise temporary instance allocations for slices. |
paul@374 | 241 | |
paul@374 | 242 | def getslice(a, b, c): |
paul@374 | 243 | return a.__getitem__(slice(b, c)) |
paul@374 | 244 | |
paul@374 | 245 | def setslice(a, b, c, d): |
paul@374 | 246 | a.__setitem__(slice(b, c), d) |
paul@374 | 247 | |
paul@324 | 248 | # vim: tabstop=4 expandtab shiftwidth=4 |