1 /* 2 * This file is part of ltrace. 3 * Copyright (C) 2011,2012,2013 Petr Machata, Red Hat Inc. 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License as 7 * published by the Free Software Foundation; either version 2 of the 8 * License, or (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 18 * 02110-1301 USA 19 */ 20 21 #ifndef EXPR_H 22 #define EXPR_H 23 24 #include "value.h" 25 #include "value_dict.h" 26 27 /* Expressions serve as a way of encoding array lengths. */ 28 29 enum expr_node_kind { 30 EXPR_OP_SELF, /* reference to the variable in question */ 31 EXPR_OP_NAMED, /* value of named argument */ 32 EXPR_OP_ARGNO, /* value of numbered argument */ 33 EXPR_OP_CONST, /* constant value */ 34 EXPR_OP_INDEX, /* A[B] */ 35 EXPR_OP_UP, /* reference to containing structure */ 36 EXPR_OP_CALL1, /* internal callback with one operand */ 37 EXPR_OP_CALL2, /* internal callback with two operands */ 38 }; 39 40 struct expr_node { 41 enum expr_node_kind kind; 42 43 struct expr_node *lhs; 44 int own_lhs; 45 46 union { 47 struct { 48 const char *s; 49 int own; 50 } name; 51 struct { 52 struct expr_node *n; 53 int own; 54 } node; 55 struct value value; 56 size_t num; 57 struct { 58 union { 59 int (*cb1)(struct value *ret_value, 60 struct value *lhs, 61 struct value_dict *arguments, 62 void *data); 63 int (*cb2)(struct value *ret_value, 64 struct value *lhs, 65 struct value *rhs, 66 struct value_dict *arguments, 67 void *data); 68 } u; 69 void *data; 70 struct expr_node *rhs; 71 int own_rhs; 72 } call; 73 } u; 74 }; 75 76 /* Expression of type self just returns the value in consideration. 77 * For example, if what we seek is length of an array, then the value 78 * representing that array is returned by the expression. */ 79 void expr_init_self(struct expr_node *node); 80 81 /* Expression that yields the value of an argument named NAME. NAME 82 * is owned if OWN_NAME. */ 83 void expr_init_named(struct expr_node *node, 84 const char *name, int own_name); 85 86 /* Expression that yields the value of an argument number NUM. */ 87 void expr_init_argno(struct expr_node *node, size_t num); 88 89 /* Constant expression always returns the same value VAL. VAL is 90 * copied into NODE and owned by it. */ 91 void expr_init_const(struct expr_node *node, struct value *val); 92 void expr_init_const_word(struct expr_node *node, long l, 93 struct arg_type_info *type, int own_type); 94 95 /* Expression LHS[RHS]. LHS and RHS are owned if, respectively, 96 * OWN_LHS and OWN_RHS. */ 97 void expr_init_index(struct expr_node *node, 98 struct expr_node *lhs, int own_lhs, 99 struct expr_node *rhs, int own_rhs); 100 101 /* This expression returns the containing value of LHS (^LHS). LHS is 102 * owned if OWN_LHS. */ 103 void expr_init_up(struct expr_node *node, struct expr_node *lhs, int own_lhs); 104 105 /* Callback expression calls CB(eval(LHS), DATA). LHS is owned if 106 * OWN_LHS. DATA is passed to callback verbatim. */ 107 void expr_init_cb1(struct expr_node *node, 108 int (*cb)(struct value *ret_value, 109 struct value *value, 110 struct value_dict *arguments, 111 void *data), 112 struct expr_node *lhs, int own_lhs, void *data); 113 114 /* Callback expression calls CB(eval(LHS), eval(RHS), DATA). LHS and 115 * RHS are owned if, respectively, OWN_LHS and OWN_RHS. DATA is 116 * passed to callback verbatim. */ 117 void expr_init_cb2(struct expr_node *node, 118 int (*cb)(struct value *ret_value, 119 struct value *lhs, struct value *rhs, 120 struct value_dict *arguments, 121 void *data), 122 struct expr_node *lhs, int own_lhs, 123 struct expr_node *rhs, int own_rhs, void *data); 124 125 /* Release the data inside NODE. Doesn't free NODE itself. */ 126 void expr_destroy(struct expr_node *node); 127 128 /* Copy expression NODE into the area pointed to by RETP. Return 0 on 129 * success or a negative value on failure. */ 130 int expr_clone(struct expr_node *retp, const struct expr_node *node); 131 132 /* Evaluate the expression NODE in context of VALUE. ARGUMENTS is a 133 * dictionary of named and numbered values that NODE may use. Returns 134 * 0 in case of success or a negative value on error. CONTEXT and 135 * ARGUMENTS may be NULL, but then the expression mustn't need them 136 * for evaluation. */ 137 int expr_eval(struct expr_node *node, struct value *context, 138 struct value_dict *arguments, struct value *ret_value); 139 140 /* Evaluate compile-time expression. Returns 0 on success or negative 141 * value on failure. Computed value is passed back in *VALUEP. */ 142 int expr_eval_constant(struct expr_node *node, long *valuep); 143 144 /* Evaluate expression, whose result should fit into a word. In order 145 * to easily support all the structure and array accesses, we simply 146 * operate on values represented by struct value. But eventually we need 147 * to be able to get out a word-size datum to use it as an index, a 148 * length, etc. */ 149 int expr_eval_word(struct expr_node *node, struct value *context, 150 struct value_dict *arguments, long *ret_value); 151 152 /* Returns non-zero value if the expression is a compile-time 153 * constant. Currently this is only EXPR_OP_CONST, but eventually 154 * things like sizeof or simple expressions might be allowed. */ 155 int expr_is_compile_constant(struct expr_node *node); 156 157 /* Returns a pre-computed expression "self". */ 158 struct expr_node *expr_self(void); 159 160 #endif /* EXPR_H */ 161