add macros

Author: WolframAlph

Python/codegen.c

@@ -5359,72 +5359,86 @@ codegen_slice(compiler *c, expr_ty s)
 #define MATCH_VALUE_EXPR(N) \
     ((N)->kind == Constant_kind || (N)->kind == Attribute_kind)
 
-static bool
-is_unary_or_complex_expr(expr_ty e)
-{
-    if (e->kind != UnaryOp_kind) {
-        return false;
-    }
-    if (e->v.UnaryOp.op != USub) {
-        return false;
-    }
-    if (e->v.UnaryOp.operand->kind != Constant_kind) {
-        return false;
-    }
-    PyObject *constant = e->v.UnaryOp.operand->v.Constant.value;
-    return PyLong_CheckExact(constant) || PyFloat_CheckExact(constant) || PyComplex_CheckExact(constant);
-}
+#define IS_CONST_EXPR(N) \
+    ((N)->kind == Constant_kind)
 
-static bool
-is_complex_binop_expr(expr_ty e)
-{
-    if (e->kind != BinOp_kind) {
-        return false;
-    }
-    if (e->v.BinOp.op != Add && e->v.BinOp.op != Sub) {
-        return false;
-    }
-    if (e->v.BinOp.right->kind != Constant_kind) {
-        return false;
-    }
-    if (e->v.BinOp.left->kind != Constant_kind && e->v.BinOp.left->kind != UnaryOp_kind) {
-        return false;
-    }
-    PyObject *leftconst;
-    if (e->v.BinOp.left->kind == UnaryOp_kind) {
-        if (e->v.BinOp.left->v.UnaryOp.operand->kind != Constant_kind) {
-            return false;
-        }
-        if (e->v.BinOp.left->v.UnaryOp.op != USub) {
-            return false;
-        }
-        leftconst = e->v.BinOp.left->v.UnaryOp.operand->v.Constant.value;
-    }
-    else {
-        leftconst = e->v.BinOp.left->v.Constant.value;
-    }
-    PyObject *rightconst = e->v.BinOp.right->v.Constant.value;
-    return (PyLong_CheckExact(leftconst) || PyFloat_CheckExact(leftconst)) && PyComplex_CheckExact(rightconst);
-}
+#define CONST_EXPR_VALUE(N) \
+    ((N)->v.Constant.value)
+
+#define IS_COMPLEX_CONST_EXPR(N) \
+    (IS_CONST_EXPR(N) && PyComplex_CheckExact(CONST_EXPR_VALUE(N)))
+
+#define IS_NUMERIC_CONST_EXPR(N) \
+    (IS_CONST_EXPR(N) && (PyLong_CheckExact(CONST_EXPR_VALUE(N)) || PyFloat_CheckExact(CONST_EXPR_VALUE(N))))
+
+#define IS_UNARY_EXPR(N) \
+    ((N)->kind == UnaryOp_kind)
+
+#define UNARY_EXPR_OP(N) \
+    ((N)->v.UnaryOp.op)
+
+#define UNARY_EXPR_OPERAND(N) \
+    ((N)->v.UnaryOp.operand)
+
+#define UNARY_EXPR_OPERAND_CONST_VALUE(N) \
+    (CONST_EXPR_VALUE(UNARY_EXPR_OPERAND(N)))
+
+#define IS_UNARY_SUB_EXPR(N) \
+    (IS_UNARY_EXPR(N) && UNARY_EXPR_OP(N) == USub)
+
+#define IS_MATCH_NUMERIC_UNARY_CONST_EXPR(N) \
+    (IS_UNARY_SUB_EXPR(N) && IS_NUMERIC_CONST_EXPR(UNARY_EXPR_OPERAND(N)))
+
+#define IS_MATCH_COMPLEX_UNARY_CONST_EXPR(N) \
+    (IS_UNARY_SUB_EXPR(N) && IS_COMPLEX_CONST_EXPR(UNARY_EXPR_OPERAND(N)))
+
+#define IS_MATCH_NUMERIC_OR_COMPLEX_UNARY_CONST_EXPR(N) \
+    (IS_MATCH_NUMERIC_UNARY_CONST_EXPR(N) || IS_MATCH_COMPLEX_UNARY_CONST_EXPR(N))
+
+#define BINARY_EXPR(N) \
+    ((N)->v.BinOp)
+
+#define BINARY_EXPR_OP(N) \
+    (BINARY_EXPR(N).op)
+
+#define BINARY_EXPR_LEFT(N) \
+    (BINARY_EXPR(N).left)
+
+#define BINARY_EXPR_RIGHT(N) \
+    (BINARY_EXPR(N).right)
+
+#define IS_BINARY_EXPR(N) \
+    ((N)->kind == BinOp_kind)
+
+#define IS_BINARY_ADD_EXPR(N) \
+    (IS_BINARY_EXPR(N) && BINARY_EXPR_OP(N) == Add)
+
+#define IS_BINARY_SUB_EXPR(N) \
+    (IS_BINARY_EXPR(N) && BINARY_EXPR_OP(N) == Sub)
+
+#define IS_MATCH_COMPLEX_BINARY_CONST_EXPR(N) \
+    ( \
+        (IS_BINARY_ADD_EXPR(N) || IS_BINARY_SUB_EXPR(N)) \
+        && (IS_MATCH_NUMERIC_UNARY_CONST_EXPR(BINARY_EXPR_LEFT(N)) || IS_CONST_EXPR(BINARY_EXPR_LEFT(N))) \
+        && IS_COMPLEX_CONST_EXPR(BINARY_EXPR_RIGHT(N)) \
+    )
 
 static void
 fold_node(expr_ty node, PyObject *folded)
 {
-    assert(node->kind != Constant_kind);
+    assert(!IS_CONST_EXPR(node));
     node->kind = Constant_kind;
     node->v.Constant.kind = NULL;
     node->v.Constant.value = folded;
 }
 
 static int
-fold_unary_or_complex_expr(expr_ty e)
+fold_const_unary_or_complex_expr(expr_ty e)
 {
-    assert(e->kind == UnaryOp_kind);
-    assert(e->v.UnaryOp.op == USub);
-    assert(e->v.UnaryOp.operand->kind == Constant_kind);
-    PyObject *operand = e->v.UnaryOp.operand->v.Constant.value;
-    assert(PyLong_CheckExact(operand) || PyFloat_CheckExact(operand) || PyComplex_CheckExact(operand));
-    PyObject* folded = PyNumber_Negative(operand);
+    assert(IS_MATCH_NUMERIC_OR_COMPLEX_UNARY_CONST_EXPR(e));
+    PyObject *constant = UNARY_EXPR_OPERAND_CONST_VALUE(e);
+    assert(UNARY_EXPR_OP(e) == USub);
+    PyObject* folded = PyNumber_Negative(constant);
     if (folded == NULL) {
         return ERROR;
     }
@@ -5433,21 +5447,19 @@ fold_unary_or_complex_expr(expr_ty e)
 }
 
 static int
-fold_binary_complex_expr(expr_ty e)
+fold_const_binary_complex_expr(expr_ty e)
 {
-    assert(e->kind == BinOp_kind);
-    assert(e->v.BinOp.right->kind == Constant_kind);
-    assert(e->v.BinOp.left->kind == UnaryOp_kind || e->v.BinOp.left->kind == Constant_kind);
-    if (e->v.BinOp.left->kind == UnaryOp_kind) {
-        RETURN_IF_ERROR(fold_unary_or_complex_expr(e->v.BinOp.left));
+    assert(IS_MATCH_COMPLEX_BINARY_CONST_EXPR(e));
+    expr_ty left_expr = BINARY_EXPR_LEFT(e);
+    if (IS_UNARY_EXPR(left_expr)) {
+        assert(IS_MATCH_NUMERIC_UNARY_CONST_EXPR(left_expr));
+        RETURN_IF_ERROR(fold_const_unary_or_complex_expr(left_expr));
     }
-    assert(e->v.BinOp.left->kind == Constant_kind);
-    operator_ty op = e->v.BinOp.op;
-    PyObject *left = e->v.BinOp.left->v.Constant.value;
-    PyObject *right = e->v.BinOp.right->v.Constant.value;
+    assert(IS_CONST_EXPR(BINARY_EXPR_LEFT(e)));
+    operator_ty op = BINARY_EXPR_OP(e);
+    PyObject *left = CONST_EXPR_VALUE(BINARY_EXPR_LEFT(e));
+    PyObject *right = CONST_EXPR_VALUE(BINARY_EXPR_RIGHT(e));
     assert(op == Add || op == Sub);
-    assert(PyLong_CheckExact(left) || PyFloat_CheckExact(left));
-    assert(PyComplex_CheckExact(right));
     PyObject *folded = op == Add ? PyNumber_Add(left, right) : PyNumber_Subtract(left, right);
     if (folded == NULL) {
         return ERROR;
@@ -5457,13 +5469,13 @@ fold_binary_complex_expr(expr_ty e)
 }
 
 static int
-try_fold_unary_or_binary_complex_const_expr(expr_ty key)
+try_fold_unary_or_binary_complex_const_expr(expr_ty e)
 {
-    if (is_unary_or_complex_expr(key)) {
-        return fold_unary_or_complex_expr(key);
+    if (IS_MATCH_NUMERIC_OR_COMPLEX_UNARY_CONST_EXPR(e)) {
+        return fold_const_unary_or_complex_expr(e);
     }
-    if (is_complex_binop_expr(key)) {
-        return fold_binary_complex_expr(key);
+    if (IS_MATCH_COMPLEX_BINARY_CONST_EXPR(e)) {
+        return fold_const_binary_complex_expr(e);
     }
     return SUCCESS;
 }