contrib/gdb-7/gdb/wrapper.c

   1 /* Longjump free calls to GDB internal routines.
   2
   3    Copyright (C) 1999-2000, 2005, 2007-2012 Free Software Foundation,
   4    Inc.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "defs.h"
  20 #include "value.h"
  21 #include "exceptions.h"
  22 #include "wrapper.h"
  23 #include "ui-out.h"
  24 #include "target.h"
  25
  26 int
  27 gdb_parse_exp_1 (char **stringptr, struct block *block, int comma,
  28                  struct expression **expression)
  29 {
  30   volatile struct gdb_exception except;
  31
  32   TRY_CATCH (except, RETURN_MASK_ERROR)
  33     {
  34       *expression = parse_exp_1 (stringptr, block, comma);
  35     }
  36
  37   if (except.reason < 0)
  38     return 0;
  39   return 1;
  40 }
  41
  42 int
  43 gdb_evaluate_expression (struct expression *exp, struct value **value)
  44 {
  45   volatile struct gdb_exception except;
  46
  47   TRY_CATCH (except, RETURN_MASK_ERROR)
  48     {
  49       *value = evaluate_expression(exp);
  50     }
  51
  52   if (except.reason < 0)
  53     return 0;
  54   return 1;
  55 }
  56
  57 int
  58 gdb_value_fetch_lazy (struct value *val)
  59 {
  60   volatile struct gdb_exception except;
  61
  62   TRY_CATCH (except, RETURN_MASK_ERROR)
  63     {
  64       value_fetch_lazy (val);
  65     }
  66
  67   if (except.reason < 0)
  68     return 0;
  69   return 1;
  70 }
  71
  72 int
  73 gdb_value_equal (struct value *val1, struct value *val2, int *result)
  74 {
  75   volatile struct gdb_exception except;
  76
  77   TRY_CATCH (except, RETURN_MASK_ERROR)
  78     {
  79       *result = value_equal (val1, val2);
  80     }
  81
  82   if (except.reason < 0)
  83     return 0;
  84   return 1;
  85 }
  86
  87 int
  88 gdb_value_assign (struct value *val1, struct value *val2,
  89                   struct value **result)
  90 {
  91   volatile struct gdb_exception except;
  92
  93   TRY_CATCH (except, RETURN_MASK_ERROR)
  94     {
  95       *result = value_assign (val1, val2);
  96     }
  97
  98   if (except.reason < 0)
  99     return 0;
 100   return 1;
 101 }
 102
 103 int
 104 gdb_value_subscript (struct value *val, LONGEST index,
 105                      struct value **result)
 106 {
 107   volatile struct gdb_exception except;
 108
 109   TRY_CATCH (except, RETURN_MASK_ERROR)
 110     {
 111       *result = value_subscript (val, index);
 112     }
 113
 114   if (except.reason < 0)
 115     return 0;
 116   return 1;
 117 }
 118
 119 int
 120 gdb_value_ind (struct value *val, struct value **result)
 121 {
 122   volatile struct gdb_exception except;
 123
 124   TRY_CATCH (except, RETURN_MASK_ERROR)
 125     {
 126       *result = value_ind (val);
 127     }
 128
 129   if (except.reason < 0)
 130     return 0;
 131   return 1;
 132 }
 133
 134 int
 135 gdb_parse_and_eval_type (char *p, int length, struct type **type)
 136 {
 137   volatile struct gdb_exception except;
 138
 139   TRY_CATCH (except, RETURN_MASK_ERROR)
 140     {
 141       *type = parse_and_eval_type (p, length);
 142     }
 143
 144   if (except.reason < 0)
 145     return 0;
 146   return 1;
 147 }
 148
 149 enum gdb_rc
 150 gdb_value_struct_elt (struct ui_out *uiout, struct value **result,
 151                       struct value **argp, struct value **args, char *name,
 152                       int *static_memfuncp, char *err)
 153 {
 154   volatile struct gdb_exception except;
 155
 156   TRY_CATCH (except, RETURN_MASK_ERROR)
 157     {
 158       *result = value_struct_elt (argp, args, name, static_memfuncp, err);
 159     }
 160
 161   if (except.reason < 0)
 162     return GDB_RC_FAIL;
 163   return GDB_RC_OK;
 164 }
 165
 166 /* Call target_find_new_threads without throwing exception.  Exception is
 167    printed if it got thrown.  */
 168
 169 int
 170 gdb_target_find_new_threads (void)
 171 {
 172   volatile struct gdb_exception except;
 173
 174   TRY_CATCH (except, RETURN_MASK_ERROR)
 175     {
 176       target_find_new_threads ();
 177     }
 178
 179   if (except.reason < 0)
 180     {
 181       exception_print (gdb_stderr, except);
 182       return 0;
 183     }
 184   return 1;
 185 }