|  | 
| "void" | consume_cexpr (self, "cexpr_t" e) | 
|  | consume_cexpr(self, e) 
 | 
|  | 
| "bool" | __eq__ (self, "carg_t" r) | 
|  | eq(self, r) -> bool 
 | 
|  | 
| "bool" | __ne__ (self, "carg_t" r) | 
|  | ne(self, r) -> bool 
 | 
|  | 
| "bool" | __lt__ (self, "carg_t" r) | 
|  | lt(self, r) -> bool 
 | 
|  | 
| "bool" | __gt__ (self, "carg_t" r) | 
|  | gt(self, r) -> bool 
 | 
|  | 
| "bool" | __le__ (self, "carg_t" r) | 
|  | le(self, r) -> bool 
 | 
|  | 
| "bool" | __ge__ (self, "carg_t" r) | 
|  | ge(self, r) -> bool 
 | 
|  | 
| "int" | compare (self, "carg_t" r) | 
|  | compare(self, r) -> int 
 | 
|  | 
|  | __init__ (self) | 
|  | init(self) -> carg_t 
 | 
|  | 
| "bool" | cpadone (self) | 
|  | cpadone(self) -> bool Pointer arithmetic correction done for this expression? 
 | 
|  | 
| "bool" | is_odd_lvalue (self) | 
|  | is_odd_lvalue(self) -> bool 
 | 
|  | 
| "bool" | is_fpop (self) | 
|  | is_fpop(self) -> bool 
 | 
|  | 
| "bool" | is_cstr (self) | 
|  | is_cstr(self) -> bool 
 | 
|  | 
| "bool" | is_undef_val (self) | 
|  | is_undef_val(self) -> bool 
 | 
|  | 
| "bool" | is_jumpout (self) | 
|  | is_jumpout(self) -> bool 
 | 
|  | 
| "bool" | is_vftable (self) | 
|  | is_vftable(self) -> bool 
 | 
|  | 
| "void" | set_cpadone (self) | 
|  | set_cpadone(self) 
 | 
|  | 
| "void" | set_vftable (self) | 
|  | set_vftable(self) 
 | 
|  | 
| "void" | swap (self, "cexpr_t" r) | 
|  | swap(self, r) 
 | 
|  | 
| "cexpr_t &" | assign (self, "cexpr_t" r) | 
|  | assign(self, r) -> cexpr_t 
 | 
|  | 
| "void" | cleanup (self) | 
|  | cleanup(self) Cleanup the expression. 
 | 
|  | 
| "void" | put_number (self, *args) | 
|  | put_number(self, func, value, nbytes, sign=no_sign) Assign a number to the expression. 
 | 
|  | 
| "void" | print1 (self, "cfunc_t" func) | 
|  | print1(self, func) Print expression into one line. 
 | 
|  | 
| "void" | calc_type (self, "bool" recursive) | 
|  | calc_type(self, recursive) Calculate the type of the expression. 
 | 
|  | 
| "bool" | equal_effect (self, "cexpr_t" r) | 
|  | equal_effect(self, r) -> bool Compare two expressions. 
 | 
|  | 
| "bool" | is_child_of (self, "citem_t" parent) | 
|  | is_child_of(self, parent) -> bool Verify if the specified item is our parent. 
 | 
|  | 
| "bool" | contains_operator (self, "ctype_t" needed_op, "int" times=1) | 
|  | contains_operator(self, needed_op, times=1) -> bool Check if the expression contains the specified operator. 
 | 
|  | 
| "bool" | contains_comma (self, "int" times=1) | 
|  | contains_comma(self, times=1) -> bool Does the expression contain a comma operator? 
 | 
|  | 
| "bool" | contains_insn (self, "int" times=1) | 
|  | contains_insn(self, times=1) -> bool Does the expression contain an embedded statement operator? 
 | 
|  | 
| "bool" | contains_insn_or_label (self) | 
|  | contains_insn_or_label(self) -> bool Does the expression contain an embedded statement operator or a label? 
 | 
|  | 
| "bool" | contains_comma_or_insn_or_label (self, "int" maxcommas=1) | 
|  | contains_comma_or_insn_or_label(self, maxcommas=1) -> bool Does the expression contain a comma operator or an embedded statement operator or a label? 
 | 
|  | 
| "bool" | is_nice_expr (self) | 
|  | is_nice_expr(self) -> bool Is nice expression? Nice expressions do not contain comma operators, embedded statements, or labels. 
 | 
|  | 
| "bool" | is_nice_cond (self) | 
|  | is_nice_cond(self) -> bool Is nice condition?. 
 | 
|  | 
| "bool" | is_call_object_of (self, "citem_t" parent) | 
|  | is_call_object_of(self, parent) -> bool Is call object? 
 | 
|  | 
| "bool" | is_call_arg_of (self, "citem_t" parent) | 
|  | is_call_arg_of(self, parent) -> bool Is call argument? 
 | 
|  | 
| "type_sign_t" | get_type_sign (self) | 
|  | get_type_sign(self) -> type_sign_t Get expression sign. 
 | 
|  | 
| "bool" | is_type_unsigned (self) | 
|  | is_type_unsigned(self) -> bool Is expression unsigned? 
 | 
|  | 
| "bool" | is_type_signed (self) | 
|  | is_type_signed(self) -> bool Is expression signed? 
 | 
|  | 
| "bit_bound_t" | get_high_nbit_bound (self) | 
|  | get_high_nbit_bound(self) -> bit_bound_t Get max number of bits that can really be used by the expression. 
 | 
|  | 
| "int" | get_low_nbit_bound (self) | 
|  | get_low_nbit_bound(self) -> int Get min number of bits that are certainly required to represent the expression. 
 | 
|  | 
| "bool" | requires_lvalue (self, "cexpr_t" child) | 
|  | requires_lvalue(self, child) -> bool Check if the expression requires an lvalue. 
 | 
|  | 
| "bool" | has_side_effects (self) | 
|  | has_side_effects(self) -> bool Check if the expression has side effects. 
 | 
|  | 
| "uint64" | numval (self) | 
|  | numval(self) -> uint64 Get numeric value of the expression. 
 | 
|  | 
| "bool" | is_const_value (self, "uint64" _v) | 
|  | is_const_value(self, _v) -> bool Check if the expression is a number with the specified value. 
 | 
|  | 
| "bool" | is_negative_const (self) | 
|  | is_negative_const(self) -> bool Check if the expression is a negative number. 
 | 
|  | 
| "bool" | is_non_negative_const (self) | 
|  | is_non_negative_const(self) -> bool Check if the expression is a non-negative number. 
 | 
|  | 
| "bool" | is_non_zero_const (self) | 
|  | is_non_zero_const(self) -> bool Check if the expression is a non-zero number. 
 | 
|  | 
| "bool" | is_zero_const (self) | 
|  | is_zero_const(self) -> bool Check if the expression is a zero. 
 | 
|  | 
| "bool" | get_const_value (self) | 
|  | get_const_value(self) -> bool Get expression value. 
 | 
|  | 
| "bool" | maybe_ptr (self) | 
|  | maybe_ptr(self) -> bool May the expression be a pointer? 
 | 
|  | 
| "cexpr_t *" | get_ptr_or_array (self) | 
|  | get_ptr_or_array(self) -> cexpr_t Find pointer or array child. 
 | 
|  | 
| "cexpr_t *" | find_op (self, *args) | 
|  | find_op(self, _op) -> cexpr_t 
 | 
|  | 
| "cexpr_t *" | find_num_op (self, *args) | 
|  | find_num_op(self) -> cexpr_t 
 | 
|  | 
| "cexpr_t *" | theother (self, *args) | 
|  | theother(self, what) -> cexpr_t 
 | 
|  | 
| "bool" | get_1num_op (self, "cexpr_t **" o1, "cexpr_t **" o2) | 
|  | get_1num_op(self, o1, o2) -> bool 
 | 
|  | 
| "char const *" | dstr (self) | 
|  | dstr(self) -> char const * 
 | 
|  | 
| "var_ref_t *" | get_v (self) | 
|  | get_v(self) -> var_ref_t 
 | 
|  | 
| "void" | set_v (self, "var_ref_t" v) | 
|  | set_v(self, v) 
 | 
|  | 
| "bool" | is_expr (self) | 
|  | is_expr(self) -> bool Is an expression? 
 | 
|  | 
| "bool" | contains_expr (self, "cexpr_t" e) | 
|  | contains_expr(self, e) -> bool Does the item contain an expression? 
 | 
|  | 
| "bool" | contains_label (self) | 
|  | contains_label(self) -> bool Does the item contain a label? 
 | 
|  | 
| "citem_t *" | find_parent_of (self, *args) | 
|  | find_parent_of(self, sitem) -> citem_t 
 | 
|  | 
| "citem_t *" | find_closest_addr (self, "ea_t" _ea) | 
|  | find_closest_addr(self, _ea) -> citem_t 
 | 
|  | 
|  | replace_by (self, o) | 
|  | 
|  | 
| "void" | _replace_by (self, "cexpr_t" r) | 
|  | _replace_by(self, r) 
 | 
|  | 
| "void" | _register (self) | 
|  | _register(self) 
 | 
|  | 
| "void" | _deregister (self) | 
|  | _deregister(self) 
 | 
|  | 
| "cnumber_t *" | _get_n (self) | 
|  | _get_n(self) -> cnumber_t 
 | 
|  | 
| "void" | _set_n (self, "cnumber_t" _v) | 
|  | _set_n(self, _v) 
 | 
|  | 
| "fnumber_t *" | _get_fpc (self) | 
|  | _get_fpc(self) -> fnumber_t 
 | 
|  | 
| "void" | _set_fpc (self, "fnumber_t" _v) | 
|  | _set_fpc(self, _v) 
 | 
|  | 
| "cexpr_t *" | _get_x (self) | 
|  | _get_x(self) -> cexpr_t 
 | 
|  | 
| "void" | _set_x (self, "cexpr_t" _v) | 
|  | _set_x(self, _v) 
 | 
|  | 
| "cexpr_t *" | _get_y (self) | 
|  | _get_y(self) -> cexpr_t 
 | 
|  | 
| "void" | _set_y (self, "cexpr_t" _v) | 
|  | _set_y(self, _v) 
 | 
|  | 
| "cexpr_t *" | _get_z (self) | 
|  | _get_z(self) -> cexpr_t 
 | 
|  | 
| "void" | _set_z (self, "cexpr_t" _v) | 
|  | _set_z(self, _v) 
 | 
|  | 
| "carglist_t *" | _get_a (self) | 
|  | _get_a(self) -> carglist_t 
 | 
|  | 
| "void" | _set_a (self, "carglist_t" _v) | 
|  | _set_a(self, _v) 
 | 
|  | 
| "cinsn_t *" | _get_insn (self) | 
|  | _get_insn(self) -> cinsn_t 
 | 
|  | 
| "void" | _set_insn (self, "cinsn_t" _v) | 
|  | _set_insn(self, _v) 
 | 
|  | 
| "int" | _get_m (self) | 
|  | _get_m(self) -> int 
 | 
|  | 
| "void" | _set_m (self, "int" _v) | 
|  | _set_m(self, _v) 
 | 
|  | 
| "int" | _get_ptrsize (self) | 
|  | _get_ptrsize(self) -> int 
 | 
|  | 
| "void" | _set_ptrsize (self, "int" _v) | 
|  | _set_ptrsize(self, _v) 
 | 
|  | 
| "ea_t" | _get_obj_ea (self) | 
|  | _get_obj_ea(self) -> ea_t 
 | 
|  | 
| "void" | _set_obj_ea (self, "ea_t" _v) | 
|  | _set_obj_ea(self, _v) 
 | 
|  | 
| "int" | _get_refwidth (self) | 
|  | _get_refwidth(self) -> int 
 | 
|  | 
| "void" | _set_refwidth (self, "int" _v) | 
|  | _set_refwidth(self, _v) 
 | 
|  | 
| "char const *" | _get_helper (self) | 
|  | _get_helper(self) -> char const * 
 | 
|  | 
| "void" | _set_helper (self, "char const *" _v) | 
|  | _set_helper(self, _v) 
 | 
|  | 
| "char const *" | _get_string (self) | 
|  | _get_string(self) -> char const * 
 | 
|  | 
| "void" | _set_string (self, "char const *" _v) | 
|  | _set_string(self, _v) 
 | 
|  | 
| "ctype_t" | _get_op (self) | 
|  | _get_op(self) -> ctype_t 
 | 
|  | 
| "void" | _set_op (self, "ctype_t" v) | 
|  | _set_op(self, v) 
 | 
|  | 
|  | _ensure_no_op (self) | 
|  | 
| "PyObject *" | _obj_id (self) | 
|  | _obj_id(self) -> PyObject * 
 | 
|  | 
|  | _ensure_cond (self, ok, cond_str) | 
|  | 
|  | _ensure_no_obj (self, o, attr, attr_is_acquired) | 
|  | 
|  | _ensure_ownership_transferrable (self, v) | 
|  | 
|  | _acquire_ownership (self, v, acquire) | 
|  | 
|  | _maybe_disown_and_deregister (self) | 
|  | 
|  | _own_and_register (self) | 
|  | 
|  | _meminfo (self) | 
|  |